gobject/valagirwriter.vala

   1 /* valagirwriter.vala
   2  *
   3  * Copyright (C) 2008  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 using Gee;
  25
  26 /**
  27  * Code visitor generating .gir file for the public interface.
  28  */
  29 public class Vala.GIRWriter : CodeVisitor {
  30         private CodeContext context;
  31
  32         FileStream stream;
  33
  34         int indent;
  35
  36         private TypeSymbol gobject_type;
  37
  38         /**
  39          * Writes the public interface of the specified code context into the
  40          * specified file.
  41          *
  42          * @param context  a code context
  43          * @param filename a relative or absolute filename
  44          */
  45         public void write_file (CodeContext context, string filename) {
  46                 this.context = context;
  47
  48                 var root_symbol = context.root;
  49                 var glib_ns = root_symbol.scope.lookup ("GLib");
  50                 gobject_type = (TypeSymbol) glib_ns.scope.lookup ("Object");
  51
  52                 stream = FileStream.open (filename, "w");
  53
  54                 stream.printf ("<?xml version=\"1.0\"?>\n");
  55
  56                 stream.printf ("<repository version=\"1.0\">\n");
  57
  58                 context.accept (this);
  59
  60                 stream.printf ("</repository>\n");
  61
  62                 stream = null;
  63         }
  64
  65         public override void visit_namespace (Namespace ns) {
  66                 if (ns.external_package) {
  67                         return;
  68                 }
  69
  70                 if (ns.name == null)  {
  71                         // global namespace
  72                         ns.accept_children (this);
  73                         return;
  74                 }
  75
  76                 if (ns.parent_symbol.name != null) {
  77                         // nested namespace
  78                         // not supported in GIR at the moment
  79                         return;
  80                 }
  81
  82                 write_indent ();
  83                 stream.printf ("<namespace name=\"%s\" version=\"1.0\">\n", ns.name);
  84                 indent++;
  85
  86                 ns.accept_children (this);
  87
  88                 indent--;
  89                 write_indent ();
  90                 stream.printf ("</namespace>\n");
  91         }
  92
  93         public override void visit_class (Class cl) {
  94                 if (cl.external_package) {
  95                         return;
  96                 }
  97
  98                 if (!check_accessibility (cl)) {
  99                         return;
 100                 }
 101
 102                 if (cl.is_subtype_of (gobject_type)) {
 103                         write_indent ();
 104                         stream.printf ("<class name=\"%s\"", cl.name);
 105                         stream.printf (" parent=\"%s\"", cl.base_class.get_full_name ());
 106                         stream.printf (" glib:type-name=\"%s\"", cl.get_cname ());
 107                         stream.printf (" glib:get-type=\"%sget_type\"", cl.get_lower_case_cprefix ());
 108                         stream.printf (">\n");
 109                         indent++;
 110
 111                         // write implemented interfaces
 112                         bool first = true;
 113                         foreach (DataType base_type in cl.get_base_types ()) {
 114                                 var object_type = (ObjectType) base_type;
 115                                 if (object_type.type_symbol is Interface) {
 116                                         if (first) {
 117                                                 write_indent ();
 118                                                 stream.printf ("<implements>\n");
 119                                                 indent++;
 120                                                 first = false;
 121                                         }
 122                                         write_indent ();
 123                                         stream.printf ("<interface name=\"%s\"/>\n", object_type.type_symbol.get_full_name ());
 124                                 }
 125                         }
 126                         if (!first) {
 127                                 indent--;
 128                                 write_indent ();
 129                                 stream.printf ("</implements>\n");
 130                         }
 131
 132                         cl.accept_children (this);
 133
 134                         indent--;
 135                         write_indent ();
 136                         stream.printf ("</class>\n");
 137                 } else {
 138                         write_indent ();
 139                         stream.printf ("<record name=\"%s\"", cl.name);
 140                         stream.printf (">\n");
 141                         indent++;
 142
 143                         cl.accept_children (this);
 144
 145                         indent--;
 146                         write_indent ();
 147                         stream.printf ("</record>\n");
 148                 }
 149         }
 150
 151         public override void visit_struct (Struct st) {
 152                 if (st.external_package) {
 153                         return;
 154                 }
 155
 156                 if (!check_accessibility (st)) {
 157                         return;
 158                 }
 159
 160                 write_indent ();
 161                 stream.printf ("<record name=\"%s\"", st.name);
 162                 stream.printf (">\n");
 163                 indent++;
 164
 165                 st.accept_children (this);
 166
 167                 indent--;
 168                 write_indent ();
 169                 stream.printf ("</record>\n");
 170         }
 171
 172         public override void visit_interface (Interface iface) {
 173                 if (iface.external_package) {
 174                         return;
 175                 }
 176
 177                 if (!check_accessibility (iface)) {
 178                         return;
 179                 }
 180
 181                 write_indent ();
 182                 stream.printf ("<interface name=\"%s\"", iface.name);
 183                 stream.printf (" glib:get-type=\"%sget_type\"", iface.get_lower_case_cprefix ());
 184                 stream.printf (">\n");
 185                 indent++;
 186
 187                 // write prerequisites
 188                 if (iface.get_prerequisites ().size > 0) {
 189                         write_indent ();
 190                         stream.printf ("<requires>\n");
 191                         indent++;
 192
 193                         foreach (DataType base_type in iface.get_prerequisites ()) {
 194                                 var object_type = (ObjectType) base_type;
 195                                 if (object_type.type_symbol is Class) {
 196                                         write_indent ();
 197                                         stream.printf ("<object name=\"%s\"/>\n", object_type.type_symbol.get_full_name ());
 198                                 } else if (object_type.type_symbol is Interface) {
 199                                         write_indent ();
 200                                         stream.printf ("<interface name=\"%s\"/>\n", object_type.type_symbol.get_full_name ());
 201                                 } else {
 202                                         assert_not_reached ();
 203                                 }
 204                         }
 205
 206                         indent--;
 207                         write_indent ();
 208                         stream.printf ("</requires>\n");
 209                 }
 210
 211                 iface.accept_children (this);
 212
 213                 indent--;
 214                 write_indent ();
 215                 stream.printf ("</interface>\n");
 216         }
 217
 218         public override void visit_enum (Enum en) {
 219                 if (en.external_package) {
 220                         return;
 221                 }
 222
 223                 if (!check_accessibility (en)) {
 224                         return;
 225                 }
 226
 227                 write_indent ();
 228                 stream.printf ("<enumeration name=\"%s\"", en.name);
 229                 stream.printf (" c:type=\"%s\"", en.get_cname ());
 230                 stream.printf (" glib:get-type=\"%sget_type\"", en.get_lower_case_cprefix ());
 231                 stream.printf (">\n");
 232                 indent++;
 233
 234                 en.accept_children (this);
 235
 236                 indent--;
 237                 write_indent ();
 238                 stream.printf ("</enumeration>\n");
 239         }
 240
 241         public override void visit_enum_value (EnumValue ev) {
 242                 write_indent ();
 243                 stream.printf ("<member name=\"%s\"/>\n", string.joinv ("-", ev.name.down ().split ("_")));
 244         }
 245
 246         public override void visit_error_domain (ErrorDomain edomain) {
 247                 if (edomain.external_package) {
 248                         return;
 249                 }
 250
 251                 if (!check_accessibility (edomain)) {
 252                         return;
 253                 }
 254
 255                 write_indent ();
 256                 stream.printf ("<errordomain name=\"%s\"", edomain.get_cname ());
 257                 stream.printf (">\n");
 258                 indent++;
 259
 260                 edomain.accept_children (this);
 261
 262                 indent--;
 263                 write_indent ();
 264                 stream.printf ("</errordomain>\n");
 265         }
 266
 267         public override void visit_error_code (ErrorCode ecode) {
 268                 write_indent ();
 269                 stream.printf ("<member name=\"%s\"/>\n", ecode.get_cname ());
 270         }
 271
 272         public override void visit_constant (Constant c) {
 273                 if (c.external_package) {
 274                         return;
 275                 }
 276
 277                 if (!check_accessibility (c)) {
 278                         return;
 279                 }
 280
 281                 write_indent ();
 282                 stream.printf ("<constant name=\"%s\"/>\n", c.get_cname ());
 283         }
 284
 285         public override void visit_field (Field f) {
 286                 if (f.external_package) {
 287                         return;
 288                 }
 289
 290                 if (!check_accessibility (f)) {
 291                         return;
 292                 }
 293
 294                 write_indent ();
 295                 stream.printf ("<field name=\"%s\">\n", f.get_cname ());
 296                 indent++;
 297
 298                 write_type (f.field_type);
 299
 300                 indent--;
 301                 write_indent ();
 302                 stream.printf ("</field>\n");
 303         }
 304
 305         private void write_params (Gee.List<FormalParameter> params, DataType? instance_type = null) {
 306                 write_indent ();
 307                 stream.printf ("<parameters>\n");
 308                 indent++;
 309
 310                 if (instance_type != null) {
 311                         write_indent ();
 312                         stream.printf ("<parameter name=\"self\">\n");
 313                         indent++;
 314
 315                         write_type (instance_type);
 316
 317                         indent--;
 318                         write_indent ();
 319                         stream.printf ("</parameter>\n");
 320                 }
 321
 322                 foreach (FormalParameter param in params) {
 323                         write_indent ();
 324                         stream.printf ("<parameter name=\"%s\"", param.name);
 325                         if (param.direction == ParameterDirection.REF) {
 326                                 stream.printf (" direction=\"inout\"");
 327                                 // in/out paramter
 328                                 if (param.parameter_type.value_owned) {
 329                                         stream.printf (" transfer-ownership=\"full\"");
 330                                 }
 331                         } else if (param.direction == ParameterDirection.OUT) {
 332                                 // out paramter
 333                                 stream.printf (" direction=\"out\"");
 334                                 if (param.parameter_type.value_owned) {
 335                                         stream.printf (" transfer-ownership=\"full\"");
 336                                 }
 337                         } else {
 338                                 // normal in paramter
 339                                 if (param.parameter_type.value_owned) {
 340                                         stream.printf (" transfer-ownership=\"full\"");
 341                                 }
 342                         }
 343                         stream.printf (">\n");
 344                         indent++;
 345
 346                         write_type (param.parameter_type);
 347
 348                         indent--;
 349                         write_indent ();
 350                         stream.printf ("</parameter>\n");
 351                 }
 352
 353                 indent--;
 354                 write_indent ();
 355                 stream.printf ("</parameters>\n");
 356         }
 357
 358         public override void visit_delegate (Delegate cb) {
 359                 if (cb.external_package) {
 360                         return;
 361                 }
 362
 363                 if (!check_accessibility (cb)) {
 364                         return;
 365                 }
 366
 367                 write_indent ();
 368                 stream.printf ("<callback name=\"%s\"", cb.get_cname ());
 369                 stream.printf (">\n");
 370                 indent++;
 371
 372                 write_params (cb.get_parameters ());
 373
 374                 write_return_type (cb.return_type);
 375
 376                 indent--;
 377                 write_indent ();
 378                 stream.printf ("</callback>\n");
 379         }
 380
 381         public override void visit_method (Method m) {
 382                 if (m.external_package) {
 383                         return;
 384                 }
 385
 386                 // don't write interface implementation unless it's an abstract or virtual method
 387                 if (!check_accessibility (m) || m.overrides || (m.base_interface_method != null && !m.is_abstract && !m.is_virtual)) {
 388                         return;
 389                 }
 390
 391                 write_indent ();
 392                 stream.printf ("<method name=\"%s\" c:identifier=\"%s\"", m.name, m.get_cname ());
 393                 stream.printf (">\n");
 394                 indent++;
 395
 396                 DataType instance_type = null;
 397                 if (m.binding == MemberBinding.INSTANCE) {
 398                         instance_type = CCodeBaseModule.get_data_type_for_symbol ((TypeSymbol) m.parent_symbol);
 399                 }
 400
 401                 write_params (m.get_parameters (), instance_type);
 402
 403                 write_return_type (m.return_type);
 404
 405                 indent--;
 406                 write_indent ();
 407                 stream.printf ("</method>\n");
 408         }
 409
 410         public override void visit_creation_method (CreationMethod m) {
 411                 if (m.external_package) {
 412                         return;
 413                 }
 414
 415                 if (!check_accessibility (m)) {
 416                         return;
 417                 }
 418
 419                 write_indent ();
 420                 stream.printf ("<constructor name=\"%s\" c:identifier=\"%s\"", m.name, m.get_cname ());
 421                 stream.printf (">\n");
 422                 indent++;
 423
 424                 write_params (m.get_parameters ());
 425
 426                 write_return_type (CCodeBaseModule.get_data_type_for_symbol ((TypeSymbol) m.parent_symbol));
 427
 428                 indent--;
 429                 write_indent ();
 430                 stream.printf ("</constructor>\n");
 431         }
 432
 433         public override void visit_property (Property prop) {
 434                 if (!check_accessibility (prop) || prop.overrides || (prop.base_interface_property != null && !prop.is_abstract && !prop.is_virtual)) {
 435                         return;
 436                 }
 437
 438                 write_indent ();
 439                 stream.printf ("<property name=\"%s\"", prop.name);
 440                 if (prop.get_accessor != null) {
 441                         stream.printf (" readable=\"1\"");
 442                 }
 443                 if (prop.set_accessor != null) {
 444                         stream.printf (" writable=\"1\"");
 445                 }
 446                 stream.printf (">\n");
 447                 indent++;
 448
 449                 write_type (prop.property_type);
 450
 451                 indent--;
 452                 write_indent ();
 453                 stream.printf ("</property>\n");
 454         }
 455
 456         public override void visit_signal (Signal sig) {
 457                 if (!check_accessibility (sig)) {
 458                         return;
 459                 }
 460
 461                 write_indent ();
 462                 stream.printf ("<glib:signal name=\"%s\"", sig.get_cname ());
 463                 stream.printf (">\n");
 464                 indent++;
 465
 466                 write_params (sig.get_parameters ());
 467
 468                 write_return_type (sig.return_type);
 469
 470                 indent--;
 471                 write_indent ();
 472                 stream.printf ("</glib:signal>\n");
 473         }
 474
 475         private void write_indent () {
 476                 int i;
 477
 478                 for (i = 0; i < indent; i++) {
 479                         stream.putc ('\t');
 480                 }
 481         }
 482
 483         private void write_return_type (DataType type) {
 484                 write_indent ();
 485                 stream.printf ("<return-value");
 486                 if (type.value_owned) {
 487                         stream.printf (" transfer-ownership=\"full\"");
 488                 }
 489                 stream.printf (">\n");
 490                 indent++;
 491
 492                 write_type (type);
 493
 494                 indent--;
 495                 write_indent ();
 496                 stream.printf ("</return-value>\n");
 497         }
 498
 499         private void write_type (DataType type) {
 500                 if (type is ArrayType) {
 501                         var array_type = (ArrayType) type;
 502
 503                         write_indent ();
 504                         stream.printf ("<array>\n");
 505                         indent++;
 506
 507                         write_type (array_type.element_type);
 508
 509                         indent--;
 510                         write_indent ();
 511                         stream.printf ("</array>\n");
 512                 } else if (type is VoidType) {
 513                         write_indent ();
 514                         stream.printf ("<type name=\"none\"/>\n");
 515                 } else {
 516                         write_indent ();
 517                         stream.printf ("<type name=\"%s\"/>\n", type.to_string ());
 518                 }
 519         }
 520
 521         private bool check_accessibility (Symbol sym) {
 522                 if (sym.access == SymbolAccessibility.PUBLIC ||
 523                     sym.access == SymbolAccessibility.PROTECTED) {
 524                         return true;
 525                 }
 526
 527                 return false;
 528         }
 529 }