vala/valainterfacewriter.vala

   1 /* valainterfacewriter.vala
   2  *
   3  * Copyright (C) 2006-2007  Jürg Billeter, Raffaele Sandrini
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the 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  *      Raffaele Sandrini <rasa@gmx.ch>
  22  */
  23
  24 using GLib;
  25
  26 /**
  27  * Code visitor generating Vala API file for the public interface.
  28  */
  29 public class Vala.InterfaceWriter : CodeVisitor {
  30         private CodeContext context;
  31
  32         FileStream stream;
  33
  34         int indent;
  35         /* at begin of line */
  36         bool bol = true;
  37
  38         string current_cheader_filename;
  39
  40         /**
  41          * Writes the public interface of the specified code context into the
  42          * specified file.
  43          *
  44          * @param context  a code context
  45          * @param filename a relative or absolute filename
  46          */
  47         public void write_file (CodeContext! context, string! filename) {
  48                 this.context = context;
  49
  50                 stream = FileStream.open (filename, "w");
  51
  52                 /* we're only interested in non-pkg source files */
  53                 foreach (SourceFile file in context.get_source_files ()) {
  54                         if (!file.pkg) {
  55                                 file.accept (this);
  56                         }
  57                 }
  58
  59                 stream = null;
  60         }
  61
  62         public override void visit_source_file (SourceFile! source_file) {
  63                 source_file.accept_children (this);
  64         }
  65
  66         public override void visit_namespace (Namespace! ns) {
  67                 if (ns.name == null)  {
  68                         ns.accept_children (this);
  69                         return;
  70                 }
  71
  72                 current_cheader_filename = ns.get_cheader_filename ();
  73
  74                 write_indent ();
  75                 write_string ("[CCode (cprefix = \"%s\", lower_case_cprefix = \"%s\", cheader_filename = \"%s\")]".printf (ns.get_cprefix (), ns.get_lower_case_cprefix (), current_cheader_filename));
  76                 write_newline ();
  77
  78                 write_indent ();
  79                 write_string ("namespace ");
  80                 write_identifier (ns.name);
  81                 write_begin_block ();
  82
  83                 ns.accept_children (this);
  84
  85                 write_end_block ();
  86                 write_newline ();
  87         }
  88
  89         public override void visit_class (Class! cl) {
  90                 if (cl.access == MemberAccessibility.PRIVATE) {
  91                         return;
  92                 }
  93
  94                 write_indent ();
  95
  96                 var first = true;
  97                 string cheaders;
  98                 foreach (string cheader in cl.get_cheader_filenames ()) {
  99                         if (first) {
 100                                 cheaders = cheader;
 101                                 first = false;
 102                         } else {
 103                                 cheaders = "%s, %s".printf (cheaders, cheader);
 104                         }
 105                 }
 106                 write_string ("[CCode (cheader_filename = \"%s\")]".printf (cheaders));
 107                 write_newline ();
 108
 109                 write_indent ();
 110                 write_string ("public ");
 111                 if (cl.is_abstract) {
 112                         write_string ("abstract ");
 113                 }
 114                 write_string ("class ");
 115                 write_identifier (cl.name);
 116
 117                 var base_types = cl.get_base_types ();
 118                 if (base_types != null) {
 119                         write_string (" : ");
 120
 121                         bool first = true;
 122                         foreach (TypeReference base_type in base_types) {
 123                                 if (!first) {
 124                                         write_string (", ");
 125                                 } else {
 126                                         first = false;
 127                                 }
 128                                 write_string (base_type.data_type.symbol.get_full_name ());
 129                         }
 130                 }
 131                 write_begin_block ();
 132
 133                 cl.accept_children (this);
 134
 135                 write_end_block ();
 136                 write_newline ();
 137         }
 138
 139         public override void visit_struct (Struct! st) {
 140                 if (st.access == MemberAccessibility.PRIVATE) {
 141                         return;
 142                 }
 143
 144                 if (st.is_reference_type ()) {
 145                         write_indent ();
 146                         write_string ("[ReferenceType]");
 147                 }
 148
 149                 write_indent ();
 150                 write_string ("public struct ");
 151                 write_identifier (st.name);
 152                 write_begin_block ();
 153
 154                 st.accept_children (this);
 155
 156                 write_end_block ();
 157                 write_newline ();
 158         }
 159
 160         public override void visit_interface (Interface! iface) {
 161                 if (iface.access == MemberAccessibility.PRIVATE) {
 162                         return;
 163                 }
 164
 165                 write_indent ();
 166
 167                 var first = true;
 168                 string cheaders;
 169                 foreach (string cheader in iface.get_cheader_filenames ()) {
 170                         if (first) {
 171                                 cheaders = cheader;
 172                                 first = false;
 173                         } else {
 174                                 cheaders = "%s, %s".printf (cheaders, cheader);
 175                         }
 176                 }
 177                 write_string ("[CCode (cheader_filename = \"%s\")]".printf (cheaders));
 178                 write_newline ();
 179
 180                 write_indent ();
 181                 write_string ("public ");
 182                 write_string ("interface ");
 183                 write_identifier (iface.name);
 184
 185                 write_begin_block ();
 186
 187                 iface.accept_children (this);
 188
 189                 write_end_block ();
 190                 write_newline ();
 191         }
 192
 193         public override void visit_enum (Enum! en) {
 194                 if (en.access == MemberAccessibility.PRIVATE) {
 195                         return;
 196                 }
 197
 198                 write_indent ();
 199                 write_string ("[CCode (cprefix = \"%s\")]".printf (en.get_cprefix ()));
 200
 201                 write_indent ();
 202                 write_string ("public enum ");
 203                 write_identifier (en.name);
 204                 write_begin_block ();
 205
 206                 en.accept_children (this);
 207
 208                 write_end_block ();
 209                 write_newline ();
 210         }
 211
 212         public override void visit_enum_value (EnumValue! ev) {
 213                 write_indent ();
 214                 write_identifier (ev.name);
 215                 write_string (",");
 216                 write_newline ();
 217         }
 218
 219         public override void visit_flags (Flags! fl) {
 220                 if (fl.access == MemberAccessibility.PRIVATE) {
 221                         return;
 222                 }
 223
 224                 write_indent ();
 225                 write_string ("[CCode (cprefix = \"%s\")]".printf (fl.get_cprefix ()));
 226
 227                 write_indent ();
 228                 write_string ("public flags ");
 229                 write_identifier (fl.name);
 230                 write_begin_block ();
 231
 232                 fl.accept_children (this);
 233
 234                 write_end_block ();
 235                 write_newline ();
 236         }
 237
 238         public override void visit_flags_value (FlagsValue! fv) {
 239                 write_indent ();
 240                 write_identifier (fv.name);
 241                 write_string (",");
 242                 write_newline ();
 243         }
 244
 245         public override void visit_constant (Constant! c) {
 246                 write_indent ();
 247                 write_string ("public const ");
 248                 write_string (c.type_reference.data_type.symbol.get_full_name ());
 249
 250                 write_string (" ");
 251                 write_identifier (c.name);
 252                 write_string (";");
 253                 write_newline ();
 254         }
 255
 256         public override void visit_field (Field! f) {
 257                 if (f.access == MemberAccessibility.PRIVATE) {
 258                         return;
 259                 }
 260
 261                 write_indent ();
 262                 write_string ("public ");
 263                 if (f.type_reference.data_type != null &&
 264                     f.type_reference.data_type.is_reference_type () &&
 265                     !f.type_reference.takes_ownership) {
 266                         write_string ("weak ");
 267                 }
 268                 write_string (f.type_reference.data_type.symbol.get_full_name ());
 269
 270                 var type_args = f.type_reference.get_type_arguments ();
 271                 if (!(f.type_reference.data_type is Array) && type_args != null) {
 272                         write_string ("<");
 273                         foreach (TypeReference type_arg in type_args) {
 274                                 if (!type_arg.takes_ownership) {
 275                                         write_string ("weak ");
 276                                 }
 277                                 write_string (type_arg.data_type.symbol.get_full_name ());
 278                         }
 279                         write_string (">");
 280                 }
 281
 282                 write_string (" ");
 283                 write_identifier (f.name);
 284                 write_string (";");
 285                 write_newline ();
 286         }
 287
 288         private void write_params (List<FormalParameter> params) {
 289                 write_string ("(");
 290
 291                 bool first = true;
 292                 foreach (FormalParameter param in params) {
 293                         if (!first) {
 294                                 write_string (", ");
 295                         } else {
 296                                 first = false;
 297                         }
 298
 299                         if (param.ellipsis) {
 300                                 write_string ("...");
 301                                 continue;
 302                         }
 303
 304                         if (param.type_reference.is_ref) {
 305                                 write_string ("ref ");
 306                         } else if (param.type_reference.is_out) {
 307                                 write_string ("out ");
 308                         }
 309                         write_string (param.type_reference.data_type.symbol.get_full_name ());
 310
 311                         var type_args = param.type_reference.get_type_arguments ();
 312                         if (!(param.type_reference.data_type is Array) && type_args != null) {
 313                                 write_string ("<");
 314                                 foreach (TypeReference type_arg in type_args) {
 315                                         if (type_arg.takes_ownership) {
 316                                                 write_string ("ref ");
 317                                         }
 318                                         write_string (type_arg.data_type.symbol.get_full_name ());
 319                                 }
 320                                 write_string (">");
 321                         }
 322
 323                         if (param.type_reference.non_null) {
 324                                 write_string ("!");
 325                         }
 326
 327                         if (param.type_reference.takes_ownership) {
 328                                 write_string ("#");
 329                         }
 330
 331                         write_string (" ");
 332                         write_identifier (param.name);
 333
 334                         if (param.default_expression != null) {
 335                                 write_string (" = ");
 336                                 write_string (param.default_expression.to_string ());
 337                         }
 338                 }
 339
 340                 write_string (")");
 341         }
 342
 343         public override void visit_callback (Callback! cb) {
 344                 if (cb.access == MemberAccessibility.PRIVATE) {
 345                         return;
 346                 }
 347
 348                 write_indent ();
 349                 write_string ("public static delegate ");
 350
 351                 var type = cb.return_type.data_type;
 352                 if (type == null) {
 353                         write_string ("void");
 354                 } else {
 355                         if (cb.return_type.transfers_ownership) {
 356                                 write_string ("ref ");
 357                         }
 358                         write_string (cb.return_type.data_type.symbol.get_full_name ());
 359                 }
 360
 361                 write_string (" ");
 362                 write_identifier (cb.name);
 363
 364                 write_string (" ");
 365
 366                 write_params (cb.get_parameters ());
 367
 368                 write_string (";");
 369
 370                 write_newline ();
 371         }
 372
 373         public override void visit_method (Method! m) {
 374                 if (m.access == MemberAccessibility.PRIVATE || m.overrides) {
 375                         return;
 376                 }
 377
 378                 if (m.no_array_length) {
 379                         bool array_found = (m.return_type != null && m.return_type.data_type is Array);
 380                         foreach (FormalParameter param in m.get_parameters ()) {
 381                                 if (param.type_reference != null && param.type_reference.data_type is Array) {
 382                                         array_found = true;
 383                                         break;
 384                                 }
 385                         }
 386                         if (array_found) {
 387                                 write_indent ();
 388                                 write_string ("[NoArrayLength]");
 389                         }
 390                 }
 391                 if (m.instance_last) {
 392                         write_indent ();
 393                         write_string ("[InstanceLast]");
 394                 }
 395                 if (m.instance_by_reference) {
 396                         write_indent ();
 397                         write_string ("[InstanceByReference]");
 398                 }
 399                 if (m.get_cname () != m.get_default_cname ()) {
 400                         write_indent ();
 401                         write_string ("[CCode (cname = \"%s\")]".printf (m.get_cname ()));
 402                 }
 403
 404                 write_indent ();
 405                 write_string ("public");
 406
 407                 if (m is CreationMethod) {
 408                         write_string (" ");
 409                         var datatype = (DataType) m.symbol.parent_symbol.node;
 410                         write_identifier (datatype.name);
 411
 412                         if (m.name != null) {
 413                                 write_string (".");
 414                                 write_identifier (m.name);
 415                         }
 416                 } else if (!m.instance) {
 417                         write_string (" static");
 418                 } else if (m.is_abstract) {
 419                         write_string (" abstract");
 420                 } else if (m.is_virtual) {
 421                         write_string (" virtual");
 422                 }
 423
 424                 if (!(m is CreationMethod)) {
 425                         write_string (" ");
 426
 427                         var type = m.return_type.data_type;
 428                         if (type == null) {
 429                                 write_string ("void");
 430                         } else {
 431                                 if (m.return_type.transfers_ownership) {
 432                                 } else if ((m.return_type.data_type != null && m.return_type.data_type.is_reference_type ()) || m.return_type.type_parameter != null) {
 433                                         write_string ("weak ");
 434                                 }
 435                                 write_string (m.return_type.data_type.symbol.get_full_name ());
 436                                 if (m.return_type.non_null) {
 437                                         write_string ("!");
 438                                 }
 439                         }
 440
 441                         write_string (" ");
 442                         write_identifier (m.name);
 443                 }
 444
 445                 write_string (" ");
 446
 447                 write_params (m.get_parameters ());
 448
 449                 write_string (";");
 450
 451                 write_newline ();
 452         }
 453
 454         public override void visit_creation_method (CreationMethod! m) {
 455                 visit_method (m);
 456         }
 457
 458         public override void visit_property (Property! prop) {
 459                 if (prop.no_accessor_method) {
 460                         write_indent ();
 461                         write_string ("[NoAccessorMethod]");
 462                 }
 463
 464                 write_indent ();
 465                 write_string ("public ");
 466                 if (!prop.type_reference.takes_ownership) {
 467                         write_string ("weak ");
 468                 }
 469                 write_string (prop.type_reference.data_type.symbol.get_full_name ());
 470
 471                 var type_args = prop.type_reference.get_type_arguments ();
 472                 if (!(prop.type_reference.data_type is Array) && type_args != null) {
 473                         write_string ("<");
 474                         foreach (TypeReference type_arg in type_args) {
 475                                 if (!type_arg.takes_ownership) {
 476                                         write_string ("weak ");
 477                                 }
 478                                 write_string (type_arg.data_type.symbol.get_full_name ());
 479                         }
 480                         write_string (">");
 481                 }
 482
 483                 write_string (" ");
 484                 write_identifier (prop.name);
 485                 write_string (" {");
 486                 if (prop.get_accessor != null) {
 487                         write_string (" get;");
 488                 }
 489                 if (prop.set_accessor != null) {
 490                         if (prop.set_accessor.writable) {
 491                                 write_string (" set");
 492                         }
 493                         if (prop.set_accessor.construction) {
 494                                 write_string (" construct");
 495                         }
 496                         write_string (";");
 497                 }
 498                 write_string (" }");
 499                 write_newline ();
 500         }
 501
 502         public override void visit_signal (Signal! sig) {
 503                 if (sig.access == MemberAccessibility.PRIVATE) {
 504                         return;
 505                 }
 506
 507                 if (sig.has_emitter) {
 508                         write_indent ();
 509                         write_string ("[HasEmitter]");
 510                 }
 511
 512                 write_indent ();
 513                 write_string ("public signal ");
 514
 515                 var type = sig.return_type.data_type;
 516                 if (type == null) {
 517                         write_string ("void");
 518                 } else {
 519                         if (sig.return_type.transfers_ownership) {
 520                                 write_string ("ref ");
 521                         }
 522                         write_string (sig.return_type.data_type.symbol.get_full_name ());
 523                         if (sig.return_type.non_null) {
 524                                 write_string ("!");
 525                         }
 526                 }
 527
 528                 write_string (" ");
 529                 write_identifier (sig.name);
 530
 531                 write_string (" ");
 532
 533                 write_params (sig.get_parameters ());
 534
 535                 write_string (";");
 536
 537                 write_newline ();
 538         }
 539
 540         private void write_indent () {
 541                 int i;
 542
 543                 if (!bol) {
 544                         stream.putc ('\n');
 545                 }
 546
 547                 for (i = 0; i < indent; i++) {
 548                         stream.putc ('\t');
 549                 }
 550
 551                 bol = false;
 552         }
 553
 554         private void write_identifier (string! s) {
 555                 if (s == "base" || s == "callback" || s == "class" ||
 556                     s == "construct" || s == "flags" || s == "foreach" ||
 557                     s == "in" || s == "interface" || s == "lock" ||
 558                     s == "namespace" || s == "out" || s == "ref") {
 559                         stream.putc ('@');
 560                 }
 561                 write_string (s);
 562         }
 563
 564         private void write_string (string! s) {
 565                 stream.printf ("%s", s);
 566                 bol = false;
 567         }
 568
 569         private void write_newline () {
 570                 stream.putc ('\n');
 571                 bol = true;
 572         }
 573
 574         private void write_begin_block () {
 575                 if (!bol) {
 576                         stream.putc (' ');
 577                 } else {
 578                         write_indent ();
 579                 }
 580                 stream.putc ('{');
 581                 write_newline ();
 582                 indent++;
 583         }
 584
 585         private void write_end_block () {
 586                 indent--;
 587                 write_indent ();
 588                 stream.printf ("}");
 589         }
 590 }