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