codegen/valagirwriter.vala

   1 /* valagirwriter.vala
   2  *
   3  * Copyright (C) 2008-2010  Jürg Billeter
   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.1 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 Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  18  *
  19  * Author:
  20  *      Jürg Billeter <j@bitron.ch>
  21  */
  22
  23 using GLib;
  24
  25 /**
  26  * Code visitor generating .gir file for the public interface.
  27  */
  28 public class Vala.GIRWriter : CodeVisitor {
  29         private CodeContext context;
  30         private string directory;
  31         private string gir_namespace;
  32         private string gir_version;
  33
  34         StringBuilder buffer = new StringBuilder();
  35         FileStream stream;
  36         Vala.HashSet<Namespace> unannotated_namespaces = new Vala.HashSet<Namespace>();
  37         Vala.HashSet<Namespace> our_namespaces = new Vala.HashSet<Namespace>();
  38
  39         int indent;
  40
  41         private TypeSymbol gobject_type;
  42
  43         private struct GIRNamespace {
  44                 public GIRNamespace (string ns, string version) {
  45                         this.ns = ns; this.version = version;
  46                 }
  47                 public string ns;
  48                 public string version;
  49                 public bool equal (GIRNamespace g) {
  50                         return ((ns == g.ns) && (version == g.version));
  51                 }
  52         }
  53
  54         private ArrayList<GIRNamespace?> externals = new ArrayList<GIRNamespace?> ((EqualFunc) GIRNamespace.equal);
  55
  56         public void write_includes() {
  57                 foreach (var i in externals) {
  58                         write_indent_stream ();
  59                         stream.printf ("<include name=\"%s\" version=\"%s\"/>\n", i.ns, i.version);
  60                 }
  61         }
  62
  63
  64         /**
  65          * Writes the public interface of the specified code context into the
  66          * specified file.
  67          *
  68          * @param context  a code context
  69          * @param filename a relative or absolute filename
  70          */
  71         public void write_file (CodeContext context, string directory, string gir_namespace, string gir_version, string package) {
  72                 this.context = context;
  73                 this.directory = directory;
  74                 this.gir_namespace = gir_namespace;
  75                 this.gir_version = gir_version;
  76
  77                 var root_symbol = context.root;
  78                 var glib_ns = root_symbol.scope.lookup ("GLib");
  79                 gobject_type = (TypeSymbol) glib_ns.scope.lookup ("Object");
  80
  81                 write_package (package);
  82
  83                 context.accept (this);
  84
  85                 indent--;
  86                 buffer.append_printf ("</repository>\n");
  87
  88                 string filename = "%s%c%s-%s.gir".printf (directory, Path.DIR_SEPARATOR, gir_namespace, gir_version);
  89                 stream = FileStream.open (filename, "w");
  90                 if (stream == null) {
  91                         Report.error (null, "unable to open `%s' for writing".printf (filename));
  92                         return;
  93                 }
  94
  95                 stream.printf ("<?xml version=\"1.0\"?>\n");
  96
  97                 stream.printf ("<repository version=\"1.1\"");
  98                 stream.printf (" xmlns=\"http://www.gtk.org/introspection/core/1.0\"");
  99                 stream.printf (" xmlns:c=\"http://www.gtk.org/introspection/c/1.0\"");
 100                 stream.printf (" xmlns:glib=\"http://www.gtk.org/introspection/glib/1.0\"");
 101                 stream.printf (">\n");
 102                 indent++;
 103
 104                 write_includes();
 105                 indent--;
 106
 107                 stream.puts (buffer.str);
 108                 stream = null;
 109
 110                 foreach (var ns in unannotated_namespaces) {
 111                         if (!our_namespaces.contains(ns)) {
 112                                 Report.warning (ns.source_reference, "Namespace %s does not have a GIR namespace and version annotation".printf (ns.name));
 113                         }
 114                 }
 115                 foreach (var ns in our_namespaces) {
 116                         ns.source_reference.file.gir_namespace = gir_namespace;
 117                         ns.source_reference.file.gir_version = gir_version;
 118                 }
 119         }
 120
 121         private void write_package (string package) {
 122                 write_indent ();
 123                 buffer.append_printf ("<package name=\"%s\"/>\n", package);
 124         }
 125
 126         private void write_c_includes (Namespace ns) {
 127                 // Collect C header filenames
 128                 Set<string> header_filenames = new HashSet<string> (str_hash, str_equal);
 129                 foreach (string c_header_filename in ns.get_cheader_filenames ()) {
 130                         header_filenames.add (c_header_filename);
 131                 }
 132                 foreach (Symbol symbol in ns.scope.get_symbol_table ().get_values ()) {
 133                         foreach (string c_header_filename in symbol.get_cheader_filenames ()) {
 134                                 header_filenames.add (c_header_filename);
 135                         }
 136                 }
 137
 138                 // Generate c:include tags
 139                 foreach (string c_header_filename in header_filenames) {
 140                         write_c_include (c_header_filename);
 141                 }
 142         }
 143
 144         private void write_c_include (string name) {
 145                 write_indent ();
 146                 buffer.append_printf ("<c:include name=\"%s\"/>\n", name);
 147         }
 148
 149         public override void visit_namespace (Namespace ns) {
 150                 if (ns.external_package) {
 151                         return;
 152                 }
 153
 154                 if (ns.name == null)  {
 155                         // global namespace
 156                         ns.accept_children (this);
 157                         return;
 158                 }
 159
 160                 if (ns.parent_symbol.name != null) {
 161                         // nested namespace
 162                         // not supported in GIR at the moment
 163                         return;
 164                 }
 165
 166                 write_c_includes (ns);
 167
 168                 write_indent ();
 169                 buffer.append_printf ("<namespace name=\"%s\" version=\"%s\"", gir_namespace, gir_version);
 170                 string? cprefix = ns.get_cprefix ();
 171                 if (cprefix != null) {
 172                         buffer.append_printf (" c:prefix=\"%s\"", cprefix);
 173                 }
 174                 buffer.append_printf (">\n");
 175                 indent++;
 176
 177                 write_annotations (ns);
 178
 179                 ns.accept_children (this);
 180
 181                 indent--;
 182                 write_indent ();
 183                 buffer.append_printf ("</namespace>\n");
 184                 our_namespaces.add(ns);
 185         }
 186
 187         public override void visit_class (Class cl) {
 188                 if (cl.external_package) {
 189                         return;
 190                 }
 191
 192                 if (!check_accessibility (cl)) {
 193                         return;
 194                 }
 195
 196                 if (cl.is_subtype_of (gobject_type)) {
 197                         string gtype_struct_name = cl.name + "Class";
 198
 199                         write_indent ();
 200                         buffer.append_printf ("<class name=\"%s\"", cl.name);
 201                         write_gtype_attributes (cl);
 202                         buffer.append_printf (" glib:type-struct=\"%s\"", gtype_struct_name);
 203                         buffer.append_printf (" parent=\"%s\"", gi_type_name (cl.base_class));
 204                         if (cl.is_abstract) {
 205                                 buffer.append_printf (" abstract=\"1\"");
 206                         }
 207                         buffer.append_printf (">\n");
 208                         indent++;
 209
 210                         // write implemented interfaces
 211                         foreach (DataType base_type in cl.get_base_types ()) {
 212                                 var object_type = (ObjectType) base_type;
 213                                 if (object_type.type_symbol is Interface) {
 214                                         write_indent ();
 215                                         buffer.append_printf ("<implements name=\"%s\"/>\n", gi_type_name (object_type.type_symbol));
 216                                 }
 217                         }
 218
 219                         write_annotations (cl);
 220
 221                         write_indent ();
 222                         buffer.append_printf ("<field name=\"parent_instance\">\n");
 223                         indent++;
 224                         write_indent ();
 225                         buffer.append_printf ("<type name=\"%s\" c:type=\"%s\"/>\n", gi_type_name (cl.base_class), cl.base_class.get_cname ());
 226                         indent--;
 227                         write_indent ();
 228                         buffer.append_printf("</field>\n");
 229
 230                         write_indent ();
 231                         buffer.append_printf ("<field name=\"priv\">\n");
 232                         indent++;
 233                         write_indent ();
 234                         buffer.append_printf ("<type name=\"any\" c:type=\"%sPrivate*\"/>\n", cl.get_cname ());
 235                         indent--;
 236                         write_indent ();
 237                         buffer.append_printf("</field>\n");
 238
 239                         cl.accept_children (this);
 240
 241                         indent--;
 242                         write_indent ();
 243                         buffer.append_printf ("</class>\n");
 244
 245                         write_indent ();
 246                         buffer.append_printf ("<record name=\"%s\"", gtype_struct_name);
 247                         write_ctype_attributes (cl, "Class");
 248                         buffer.append_printf (" glib:is-gtype-struct-for=\"%s\"", cl.name);
 249                         buffer.append_printf (">\n");
 250                         indent++;
 251
 252                         write_indent ();
 253                         buffer.append_printf ("<field name=\"parent_class\">\n");
 254                         indent++;
 255                         write_indent ();
 256                         buffer.append_printf ("<type name=\"%sClass\" c:type=\"%sClass\"/>\n", gi_type_name (cl.base_class), cl.base_class.get_cname ());
 257                         indent--;
 258                         write_indent ();
 259                         buffer.append_printf ("</field>\n");
 260
 261                         foreach (Method m in cl.get_methods ()) {
 262                                 if (m.is_abstract || m.is_virtual) {
 263                                         write_indent ();
 264                                         buffer.append_printf("<field name=\"%s\">\n", m.name);
 265                                         indent++;
 266                                         write_signature(m, "callback", true);
 267                                         indent--;
 268                                         write_indent ();
 269                                         buffer.append_printf ("</field>\n");
 270                                 }
 271                         }
 272
 273                         foreach (Signal sig in cl.get_signals ()) {
 274                                 if (sig.default_handler != null) {
 275                                         write_indent ();
 276                                         buffer.append_printf ("<field name=\"%s\">\n", sig.name);
 277                                         indent++;
 278                                         write_signature (sig.default_handler, "callback", true);
 279                                         indent--;
 280                                         write_indent ();
 281                                         buffer.append_printf ("</field>\n");
 282                                 }
 283                         }
 284
 285
 286                         indent--;
 287                         write_indent ();
 288                         buffer.append_printf ("</record>\n");
 289                 } else {
 290                         write_indent ();
 291                         buffer.append_printf ("<record name=\"%s\"", cl.name);
 292                         buffer.append_printf (">\n");
 293                         indent++;
 294
 295                         write_annotations (cl);
 296
 297                         cl.accept_children (this);
 298
 299                         indent--;
 300                         write_indent ();
 301                         buffer.append_printf ("</record>\n");
 302                 }
 303         }
 304
 305         public override void visit_struct (Struct st) {
 306                 if (st.external_package) {
 307                         return;
 308                 }
 309
 310                 if (!check_accessibility (st)) {
 311                         return;
 312                 }
 313
 314                 write_indent ();
 315                 buffer.append_printf ("<record name=\"%s\"", st.name);
 316                 buffer.append_printf (">\n");
 317                 indent++;
 318
 319                 write_annotations (st);
 320
 321                 st.accept_children (this);
 322
 323                 indent--;
 324                 write_indent ();
 325                 buffer.append_printf ("</record>\n");
 326         }
 327
 328         public override void visit_interface (Interface iface) {
 329                 if (iface.external_package) {
 330                         return;
 331                 }
 332
 333                 if (!check_accessibility (iface)) {
 334                         return;
 335                 }
 336
 337                 string gtype_struct_name = iface.name + "Iface";
 338
 339                 write_indent ();
 340                 buffer.append_printf ("<interface name=\"%s\"", iface.name);
 341                 write_gtype_attributes (iface);
 342                 buffer.append_printf (" glib:type-struct=\"%s\"", gtype_struct_name);
 343                 buffer.append_printf (">\n");
 344                 indent++;
 345
 346                 // write prerequisites
 347                 if (iface.get_prerequisites ().size > 0) {
 348                         write_indent ();
 349                         buffer.append_printf ("<requires>\n");
 350                         indent++;
 351
 352                         foreach (DataType base_type in iface.get_prerequisites ()) {
 353                                 var object_type = (ObjectType) base_type;
 354                                 if (object_type.type_symbol is Class) {
 355                                         write_indent ();
 356                                         buffer.append_printf ("<object name=\"%s\"/>\n", gi_type_name (object_type.type_symbol));
 357                                 } else if (object_type.type_symbol is Interface) {
 358                                         write_indent ();
 359                                         buffer.append_printf ("<interface name=\"%s\"/>\n", gi_type_name (object_type.type_symbol));
 360                                 } else {
 361                                         assert_not_reached ();
 362                                 }
 363                         }
 364
 365                         indent--;
 366                         write_indent ();
 367                         buffer.append_printf ("</requires>\n");
 368                 }
 369
 370                 write_annotations (iface);
 371
 372                 iface.accept_children (this);
 373
 374                 indent--;
 375                 write_indent ();
 376                 buffer.append_printf ("</interface>\n");
 377
 378                 write_indent ();
 379                 buffer.append_printf ("<record name=\"%s\"", gtype_struct_name);
 380                 write_ctype_attributes (iface, "Iface");
 381                 buffer.append_printf (" glib:is-gtype-struct-for=\"%s\"", iface.name);
 382                 buffer.append_printf (">\n");
 383                 indent++;
 384
 385                 foreach (Method m in iface.get_methods ()) {
 386                         if (m.is_abstract || m.is_virtual) {
 387                                 write_signature(m, "callback", true);
 388                         }
 389                 }
 390
 391                 indent--;
 392                 write_indent ();
 393                 buffer.append_printf ("</record>\n");
 394         }
 395
 396         public override void visit_enum (Enum en) {
 397                 if (en.external_package) {
 398                         return;
 399                 }
 400
 401                 if (!check_accessibility (en)) {
 402                         return;
 403                 }
 404
 405                 write_indent ();
 406                 buffer.append_printf ("<enumeration name=\"%s\"", en.name);
 407                 write_gtype_attributes (en);
 408                 buffer.append_printf (">\n");
 409                 indent++;
 410
 411                 write_annotations (en);
 412
 413                 enum_value = 0;
 414                 en.accept_children (this);
 415
 416                 indent--;
 417                 write_indent ();
 418                 buffer.append_printf ("</enumeration>\n");
 419         }
 420
 421         private int enum_value;
 422
 423         public override void visit_enum_value (EnumValue ev) {
 424                 write_indent ();
 425                 buffer.append_printf ("<member name=\"%s\" c:identifier=\"%s\"", ev.name.down (), ev.get_cname ());
 426                 if (ev.value != null) {
 427                         string value = literal_expression_to_value_string (ev.value);
 428                         buffer.append_printf (" value=\"%s\"", value);
 429                 } else {
 430                         buffer.append_printf (" value=\"%d\"", enum_value++);
 431                 }
 432                 buffer.append_printf ("/>\n");
 433         }
 434
 435         public override void visit_error_domain (ErrorDomain edomain) {
 436                 if (edomain.external_package) {
 437                         return;
 438                 }
 439
 440                 if (!check_accessibility (edomain)) {
 441                         return;
 442                 }
 443
 444                 write_indent ();
 445                 buffer.append_printf ("<errordomain name=\"%s\"", edomain.name);
 446                 buffer.append_printf (" get-quark=\"%squark\"", edomain.get_lower_case_cprefix ());
 447                 buffer.append_printf (" codes=\"%s\"", edomain.name);
 448                 buffer.append_printf (">\n");
 449
 450                 write_annotations (edomain);
 451
 452                 buffer.append_printf ("</errordomain>\n");
 453
 454                 write_indent ();
 455                 buffer.append_printf ("<enumeration name=\"%s\"", edomain.name);
 456                 write_ctype_attributes (edomain);
 457                 buffer.append_printf (">\n");
 458                 indent++;
 459
 460                 enum_value = 0;
 461                 edomain.accept_children (this);
 462
 463                 indent--;
 464                 write_indent ();
 465                 buffer.append_printf ("</enumeration>\n");
 466         }
 467
 468         public override void visit_error_code (ErrorCode ecode) {
 469                 write_indent ();
 470                 buffer.append_printf ("<member name=\"%s\" c:identifier=\"%s\"", ecode.name.down (), ecode.get_cname ());
 471                 if (ecode.value != null) {
 472                         string value = literal_expression_to_value_string (ecode.value);
 473                         buffer.append_printf (" value=\"%s\"", value);
 474                 } else {
 475                         buffer.append_printf (" value=\"%d\"", enum_value++);
 476                 }
 477                 buffer.append_printf ("/>\n");
 478         }
 479
 480         public override void visit_constant (Constant c) {
 481                 if (c.external_package) {
 482                         return;
 483                 }
 484
 485                 if (!check_accessibility (c)) {
 486                         return;
 487                 }
 488
 489                 //TODO Add better constant evaluation
 490                 var initializer = c.value;
 491                 string value = literal_expression_to_value_string (initializer);
 492
 493                 write_indent ();
 494                 buffer.append_printf ("<constant name=\"%s\" c:identifier=\"%s\"", c.name, c.get_cname ());
 495                 buffer.append_printf (" value=\"%s\"", value);
 496                 buffer.append_printf (">\n");
 497                 indent++;
 498
 499                 write_type (initializer.value_type);
 500
 501                 indent--;
 502                 write_indent ();
 503                 buffer.append_printf ("</constant>\n");
 504         }
 505
 506         public override void visit_field (Field f) {
 507                 if (f.external_package) {
 508                         return;
 509                 }
 510
 511                 if (!check_accessibility (f)) {
 512                         return;
 513                 }
 514
 515                 write_indent ();
 516                 buffer.append_printf ("<field name=\"%s\"", f.get_cname ());
 517                 if (f.variable_type.nullable) {
 518                         buffer.append_printf (" allow-none=\"1\"");
 519                 }
 520                 buffer.append_printf (">\n");
 521                 indent++;
 522
 523                 write_annotations (f);
 524
 525                 write_type (f.variable_type);
 526
 527                 indent--;
 528                 write_indent ();
 529                 buffer.append_printf ("</field>\n");
 530         }
 531
 532         private void write_implicit_params (DataType type, ref int index, bool has_array_length, string name, ParameterDirection direction) {
 533                 if (type is ArrayType && has_array_length) {
 534                         var int_type = new IntegerType (CodeContext.get ().root.scope.lookup ("int") as Struct);
 535                         write_param_or_return (int_type, "parameter", ref index, has_array_length, "%s_length1".printf (name), direction);
 536                 } else if (type is DelegateType) {
 537                         var data_type = new PointerType (new VoidType ());
 538                         write_param_or_return (data_type, "parameter", ref index, false, "%s_target".printf (name), direction);
 539                         if (type.value_owned) {
 540                                 var notify_type = new DelegateType (CodeContext.get ().root.scope.lookup ("GLib").scope.lookup ("DestroyNotify") as Delegate);
 541                                 write_param_or_return (notify_type, "parameter", ref index, false, "%s_target_destroy_notify".printf (name), direction);
 542                         }
 543                 }
 544         }
 545
 546         private void write_params_and_return (List<FormalParameter> params, DataType? return_type, bool return_array_length, bool constructor = false, DataType? instance_type = null, bool user_data = false) {
 547                 int last_index = 0;
 548                 if (params.size != 0 || instance_type != null || (return_type is ArrayType && return_array_length) || (return_type is DelegateType)) {
 549                         write_indent ();
 550                         buffer.append_printf ("<parameters>\n");
 551                         indent++;
 552                         int index = 1;
 553
 554                         if (instance_type != null) {
 555                                 write_param_or_return (instance_type, "parameter", ref index, false, "self");
 556                         }
 557
 558                         foreach (FormalParameter param in params) {
 559                                 write_param_or_return (param.variable_type, "parameter", ref index, !param.no_array_length, param.name, param.direction);
 560
 561                                 write_implicit_params (param.variable_type, ref index, !param.no_array_length, param.name, param.direction);
 562                         }
 563
 564                         last_index = index - 1;
 565                         write_implicit_params (return_type, ref index, return_array_length, "result", ParameterDirection.OUT);
 566
 567                         if (user_data) {
 568                                 write_indent ();
 569                                 buffer.append_printf ("<parameter name=\"user_data\" transfer-ownership=\"none\" closure=\"%d\">\n", index);
 570                                 indent++;
 571                                 write_indent ();
 572                                 buffer.append_printf ("<type name=\"any\" c:type=\"void*\"/>\n");
 573                                 indent--;
 574                                 write_indent ();
 575                                 buffer.append_printf ("</parameter>\n");
 576                         }
 577
 578                         indent--;
 579                         write_indent ();
 580                         buffer.append_printf ("</parameters>\n");
 581                 }
 582
 583                 if (return_type != null) {
 584                         write_param_or_return (return_type, "return-value", ref last_index, return_array_length, null, ParameterDirection.IN, constructor);
 585                 }
 586         }
 587
 588         public override void visit_delegate (Delegate cb) {
 589                 if (cb.external_package) {
 590                         return;
 591                 }
 592
 593                 if (!check_accessibility (cb)) {
 594                         return;
 595                 }
 596
 597                 write_indent ();
 598                 buffer.append_printf ("<callback name=\"%s\"", cb.name);
 599                 buffer.append_printf (" c:type=\"%s\"", cb.get_cname ());
 600                 if (cb.tree_can_fail) {
 601                         buffer.append_printf (" throws=\"1\"");
 602                 }
 603                 buffer.append_printf (">\n");
 604                 indent++;
 605
 606                 write_annotations (cb);
 607
 608                 write_params_and_return (cb.get_parameters (), cb.return_type, !cb.no_array_length, false, null, cb.has_target);
 609
 610                 indent--;
 611                 write_indent ();
 612                 buffer.append_printf ("</callback>\n");
 613         }
 614
 615         public override void visit_method (Method m) {
 616                 if (m.external_package) {
 617                         return;
 618                 }
 619
 620                 // don't write interface implementation unless it's an abstract or virtual method
 621                 if (!check_accessibility (m) || m.overrides || (m.base_interface_method != null && !m.is_abstract && !m.is_virtual)) {
 622                         return;
 623                 }
 624
 625                 string tag_name = "method";
 626                 var parent = m.parent_symbol;
 627                 if (parent is Namespace || m.binding == MemberBinding.STATIC) {
 628                         tag_name = "function";
 629                 }
 630
 631                 write_signature (m, tag_name);
 632
 633                 if (m.is_abstract || m.is_virtual) {
 634                         write_signature (m, "virtual-method", false);
 635                 }
 636         }
 637
 638         private void write_signature (Method m, string tag_name, bool instance = false) {
 639                 if (m.coroutine) {
 640                         string finish_name = m.name;
 641                         if (finish_name.has_suffix ("_async")) {
 642                                 finish_name = finish_name.substring (0, finish_name.length - "_async".length);
 643                         }
 644                         finish_name += "_finish";
 645                         do_write_signature (m, tag_name, instance, m.name, m.get_cname (), m.get_async_begin_parameters (), new VoidType (), false);
 646                         do_write_signature (m, tag_name, instance, finish_name, m.get_finish_cname (), m.get_async_end_parameters (), m.return_type, m.tree_can_fail);
 647                 } else {
 648                         do_write_signature (m, tag_name, instance, m.name, m.get_cname (), m.get_parameters (), m.return_type, m.tree_can_fail);
 649                 }
 650         }
 651
 652         private void do_write_signature (Method m, string tag_name, bool instance, string name, string cname, List<Vala.FormalParameter> params, DataType return_type, bool can_fail) {
 653                 write_indent ();
 654                 buffer.append_printf ("<%s name=\"%s\"", tag_name, name);
 655                 if (tag_name == "virtual-method") {
 656                         buffer.append_printf (" invoker=\"%s\"", name);
 657                 } else if (tag_name == "callback") {
 658                         /* this is only used for vfuncs */
 659                         buffer.append_printf (" c:type=\"%s\"", name);
 660                 } else {
 661                         buffer.append_printf (" c:identifier=\"%s\"", cname);
 662                 }
 663                 if (can_fail) {
 664                         buffer.append_printf (" throws=\"1\"");
 665                 }
 666                 buffer.append_printf (">\n");
 667                 indent++;
 668
 669                 write_annotations (m);
 670
 671                 DataType instance_type = null;
 672                 if (instance) {
 673                         instance_type = CCodeBaseModule.get_data_type_for_symbol ((TypeSymbol) m.parent_symbol);
 674                 }
 675
 676                 write_params_and_return (params, return_type, !m.no_array_length, false, instance_type);
 677
 678                 indent--;
 679                 write_indent ();
 680                 buffer.append_printf ("</%s>\n", tag_name);
 681         }
 682
 683         public override void visit_creation_method (CreationMethod m) {
 684                 if (m.external_package) {
 685                         return;
 686                 }
 687
 688                 if (!check_accessibility (m)) {
 689                         return;
 690                 }
 691
 692                 write_indent ();
 693
 694                 if (m.parent_symbol is Class && m == ((Class)m.parent_symbol).default_construction_method ||
 695                         m.parent_symbol is Struct && m == ((Struct)m.parent_symbol).default_construction_method) {
 696                         buffer.append_printf ("<constructor name=\"new\" c:identifier=\"%s\"", m.get_cname ());
 697                 } else {
 698                         buffer.append_printf ("<constructor name=\"%s\" c:identifier=\"%s\"", m.name, m.get_cname ());
 699                 }
 700
 701                 if (m.tree_can_fail) {
 702                         buffer.append_printf (" throws=\"1\"");
 703                 }
 704                 buffer.append_printf (">\n");
 705                 indent++;
 706
 707                 write_annotations (m);
 708
 709
 710                 var datatype = CCodeBaseModule.get_data_type_for_symbol ((TypeSymbol) m.parent_symbol);
 711                 write_params_and_return (m.get_parameters (), datatype, false, true);
 712
 713                 indent--;
 714                 write_indent ();
 715                 buffer.append_printf ("</constructor>\n");
 716         }
 717
 718         public override void visit_property (Property prop) {
 719                 if (!check_accessibility (prop) || prop.overrides || (prop.base_interface_property != null && !prop.is_abstract && !prop.is_virtual)) {
 720                         return;
 721                 }
 722
 723                 write_indent ();
 724                 buffer.append_printf ("<property name=\"%s\"", prop.get_canonical_name ());
 725                 if (prop.get_accessor == null) {
 726                         buffer.append_printf (" readable=\"0\"");
 727                 }
 728                 if (prop.set_accessor != null) {
 729                         buffer.append_printf (" writable=\"1\"");
 730                         if (prop.set_accessor.construction) {
 731                                 if (!prop.set_accessor.writable) {
 732                                         buffer.append_printf (" construct-only=\"1\"");
 733                                 } else {
 734                                         buffer.append_printf (" construct=\"1\"");
 735                                 }
 736                         }
 737                 }
 738                 buffer.append_printf (">\n");
 739                 indent++;
 740
 741                 write_annotations (prop);
 742
 743                 write_type (prop.property_type);
 744
 745                 indent--;
 746                 write_indent ();
 747                 buffer.append_printf ("</property>\n");
 748         }
 749
 750         public override void visit_signal (Signal sig) {
 751                 if (!check_accessibility (sig)) {
 752                         return;
 753                 }
 754
 755                 write_indent ();
 756                 buffer.append_printf ("<glib:signal name=\"%s\"", sig.get_cname ());
 757                 buffer.append_printf (">\n");
 758                 indent++;
 759
 760                 write_annotations (sig);
 761
 762                 write_params_and_return (sig.get_parameters (), sig.return_type, false);
 763
 764                 indent--;
 765                 write_indent ();
 766                 buffer.append_printf ("</glib:signal>\n");
 767         }
 768
 769         private void write_indent () {
 770                 int i;
 771
 772                 for (i = 0; i < indent; i++) {
 773                         buffer.append_c ('\t');
 774                 }
 775         }
 776
 777         private void write_indent_stream () {
 778                 int i;
 779
 780                 for (i = 0; i < indent; i++) {
 781                         stream.putc ('\t');
 782                 }
 783         }
 784
 785
 786         private void write_param_or_return (DataType type, string tag, ref int index, bool has_array_length, string? name = null, ParameterDirection direction = ParameterDirection.IN, bool constructor = false) {
 787                 write_indent ();
 788                 buffer.append_printf ("<%s", tag);
 789                 if (name != null) {
 790                         buffer.append_printf (" name=\"%s\"", name);
 791                 }
 792                 if (direction == ParameterDirection.REF) {
 793                         buffer.append_printf (" direction=\"inout\"");
 794                 } else if (direction == ParameterDirection.OUT) {
 795                         buffer.append_printf (" direction=\"out\"");
 796                 }
 797
 798                 DelegateType delegate_type = type as DelegateType;
 799
 800                 if ((type.value_owned && delegate_type == null) || constructor) {
 801                         buffer.append_printf (" transfer-ownership=\"full\"");
 802                 } else {
 803                         buffer.append_printf (" transfer-ownership=\"none\"");
 804                 }
 805                 if (type.nullable) {
 806                         buffer.append_printf (" allow-none=\"1\"");
 807                 }
 808
 809                 if (delegate_type != null && delegate_type.delegate_symbol.has_target) {
 810                         buffer.append_printf (" closure=\"%i\"", index + 1);
 811                         if (type.value_owned) {
 812                                 buffer.append_printf (" destroy=\"%i\"", index + 2);
 813                         }
 814                 }
 815
 816                 buffer.append_printf (">\n");
 817                 indent++;
 818
 819                 write_type (type, has_array_length ? index : -1);
 820
 821                 indent--;
 822                 write_indent ();
 823                 buffer.append_printf ("</%s>\n", tag);
 824                 index++;
 825         }
 826
 827         private void write_ctype_attributes (TypeSymbol symbol, string suffix = "") {
 828                 buffer.append_printf (" c:type=\"%s%s\"", symbol.get_cname (), suffix);
 829         }
 830
 831         private void write_gtype_attributes (TypeSymbol symbol) {
 832                 write_ctype_attributes(symbol);
 833                 buffer.append_printf (" glib:type-name=\"%s\"", symbol.get_cname ());
 834                 buffer.append_printf (" glib:get-type=\"%sget_type\"", symbol.get_lower_case_cprefix ());
 835         }
 836
 837         private void write_type (DataType type, int index = -1) {
 838                 if (type is ArrayType) {
 839                         var array_type = (ArrayType) type;
 840
 841                         write_indent ();
 842                         buffer.append_printf ("<array");
 843                         if (array_type.fixed_length) {
 844                                 buffer.append_printf (" fixed-length\"%i\"", array_type.length);
 845                         } else if (index != -1) {
 846                                 buffer.append_printf (" length=\"%i\"", index + 1);
 847                         }
 848                         buffer.append_printf (">\n");
 849                         indent++;
 850
 851                         write_type (array_type.element_type);
 852
 853                         indent--;
 854                         write_indent ();
 855                         buffer.append_printf ("</array>\n");
 856                 } else if (type is VoidType) {
 857                         write_indent ();
 858                         buffer.append_printf ("<type name=\"none\"/>\n");
 859                 } else if (type is PointerType) {
 860                         write_indent ();
 861                         buffer.append_printf ("<type name=\"any\" c:type=\"%s\"/>\n", type.get_cname ());
 862                 } else if (type.data_type != null) {
 863                         write_indent ();
 864                         buffer.append_printf ("<type name=\"%s\" c:type=\"%s\"", gi_type_name (type.data_type), type.get_cname ());
 865
 866                         List<DataType> type_arguments = type.get_type_arguments ();
 867                         if (type_arguments.size == 0) {
 868                                 buffer.append_printf ("/>\n");
 869                         } else {
 870                                 buffer.append_printf (">\n");
 871                                 indent++;
 872
 873                                 foreach (DataType type_argument in type_arguments) {
 874                                         write_type (type_argument);
 875                                 }
 876
 877                                 indent--;
 878                                 write_indent ();
 879                                 buffer.append_printf ("</type>\n");
 880                         }
 881                 } else if (type is DelegateType) {
 882                         var deleg_type = (DelegateType) type;
 883                         write_indent ();
 884                         buffer.append_printf ("<type name=\"%s\" c:type=\"%s\"/>\n", gi_type_name (deleg_type.delegate_symbol), type.get_cname ());
 885                 } else if (type is GenericType) {
 886                         // generic type parameters not supported in GIR
 887                         write_indent ();
 888                         buffer.append ("<type name=\"any\" c:type=\"gpointer\"/>\n");
 889                 } else {
 890                         write_indent ();
 891                         buffer.append_printf ("<type name=\"%s\"/>\n", type.to_string ());
 892                 }
 893         }
 894
 895         private void write_annotations (CodeNode node) {
 896                 foreach (Attribute attr in node.attributes) {
 897                         string name = camel_case_to_canonical (attr.name);
 898                         foreach (string arg_name in attr.args.get_keys ()) {
 899                                 var arg = attr.args.get (arg_name);
 900
 901                                 string value = literal_expression_to_value_string ((Literal) arg);
 902
 903                                 if (value != null) {
 904                                         write_indent ();
 905                                         buffer.append_printf ("<annotation key=\"%s.%s\" value=\"%s\"/>\n",
 906                                                 name, camel_case_to_canonical (arg_name), value);
 907                                 }
 908                         }
 909                 }
 910         }
 911
 912         private string gi_type_name (TypeSymbol type_symbol) {
 913                 Symbol parent = type_symbol.parent_symbol;
 914                 if (parent is Namespace) {
 915                         Namespace ns = parent as Namespace;
 916                         if (ns.name != null) {
 917                                 if (type_symbol.source_reference.file.gir_namespace != null) {
 918                                         GIRNamespace external = GIRNamespace (type_symbol.source_reference.file.gir_namespace, type_symbol.source_reference.file.gir_version);
 919                                         if (!externals.contains (external)) {
 920                                                 externals.add (external);
 921                                         }
 922                                         return "%s.%s".printf (type_symbol.source_reference.file.gir_namespace, type_symbol.name);
 923                                 } else {
 924                                         unannotated_namespaces.add(ns);
 925                                 }
 926                         }
 927                 }
 928
 929                 return vala_to_gi_type_name (type_symbol.get_full_name());
 930         }
 931
 932         private string vala_to_gi_type_name (string name) {
 933                 if (name == "bool") {
 934                         return "boolean";
 935                 } else if (name == "string") {
 936                         return "utf8";
 937                 } else if (!name.contains (".")) {
 938                         return name;
 939                 } else {
 940                         string[] split_name = name.split (".");
 941
 942                         StringBuilder type_name = new StringBuilder ();
 943                         type_name.append (split_name[0]);
 944                         type_name.append_unichar ('.');
 945                         for (int i = 1; i < split_name.length; i++) {
 946                                 type_name.append (split_name[i]);
 947                         }
 948                         return type_name.str;
 949                 }
 950         }
 951
 952         private string? literal_expression_to_value_string (Expression literal) {
 953                 if (literal is StringLiteral) {
 954                         var lit = literal as StringLiteral;
 955                         if (lit != null) {
 956                                 return Markup.escape_text (lit.eval ());
 957                         }
 958                 } else if (literal is CharacterLiteral) {
 959                         return "%c".printf ((char) ((CharacterLiteral) literal).get_char ());
 960                 } else if (literal is BooleanLiteral) {
 961                         return ((BooleanLiteral) literal).value ? "true" : "false";
 962                 } else if (literal is RealLiteral) {
 963                         return ((RealLiteral) literal).value;
 964                 } else if (literal is IntegerLiteral) {
 965                         return ((IntegerLiteral) literal).value;
 966                 } else if (literal is UnaryExpression) {
 967                         var unary = (UnaryExpression) literal;
 968                         if (unary.operator == UnaryOperator.MINUS) {
 969                                 if (unary.inner is RealLiteral) {
 970                                         return "-" + ((RealLiteral) unary.inner).value;
 971                                 } else if (unary.inner is IntegerLiteral) {
 972                                         return "-" + ((IntegerLiteral) unary.inner).value;
 973                                 }
 974                         }
 975                 }
 976                 return null;
 977         }
 978
 979         private string camel_case_to_canonical (string name) {
 980                 string[] parts = Symbol.camel_case_to_lower_case (name).split ("_");
 981                 return string.joinv ("-", parts);
 982         }
 983
 984         private bool check_accessibility (Symbol sym) {
 985                 if (sym.access == SymbolAccessibility.PUBLIC ||
 986                     sym.access == SymbolAccessibility.PROTECTED) {
 987                         return true;
 988                 }
 989
 990                 return false;
 991         }
 992 }