vala/valasourcefile.vala

   1 /* valasourcefile.vala
   2  *
   3  * Copyright (C) 2006-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  * Represents a Vala source or VAPI package file.
  28  */
  29 public class Vala.SourceFile {
  30         /**
  31          * The name of this source file.
  32          */
  33         public string filename { get; set; }
  34
  35         /**
  36          * The header comment of this source file.
  37          */
  38         public string comment { get; set; }
  39
  40         /**
  41          * Specifies whether this file is a VAPI package file.
  42          */
  43         public bool external_package { get; set; }
  44
  45         /**
  46          * Specifies the dependency cycle this source file is member of. If this
  47          * source file is in a cycle, all type definitions of that cycle will
  48          * only be written to the C header file of the cycle head.
  49          */
  50         public SourceFileCycle cycle { get; set; }
  51
  52         /**
  53          * Specifies whether this source file is the head of the cycle, if it is
  54          * in a cycle at all.
  55          */
  56         public bool is_cycle_head { get; set; }
  57
  58         /**
  59          * Mark used for cycle detection.
  60          *
  61          * 0: not yet visited
  62          * 1: currently visiting
  63          * 2: already visited
  64          */
  65         public int mark { get; set; }
  66
  67         /**
  68          * The context this source file belongs to.
  69          */
  70         public weak CodeContext context { get; set; }
  71
  72         public string? content {
  73                 get { return this._content; }
  74                 set {
  75                         this._content = value;
  76                         this.source_array = null;
  77                 }
  78         }
  79
  80         private Gee.List<UsingDirective> using_directives = new ArrayList<UsingDirective> ();
  81
  82         private Gee.List<CodeNode> nodes = new ArrayList<CodeNode> ();
  83
  84         private string cheader_filename = null;
  85         private string csource_filename = null;
  86         private string cinclude_filename = null;
  87
  88         private Gee.List<string> header_external_includes = new ArrayList<string> ();
  89         private Gee.List<string> header_internal_includes = new ArrayList<string> ();
  90         private Gee.List<string> source_external_includes = new ArrayList<string> ();
  91         private Gee.List<string> source_internal_includes = new ArrayList<string> ();
  92
  93         private Gee.List<weak SourceFile> header_internal_full_dependencies = new ArrayList<weak SourceFile> ();
  94         private Gee.List<weak SourceFile> header_internal_dependencies = new ArrayList<weak SourceFile> ();
  95
  96         private Gee.Set<Symbol> source_symbol_dependencies = new HashSet<Symbol> ();
  97
  98         private Gee.ArrayList<string> source_array = null;
  99
 100         private MappedFile mapped_file = null;
 101
 102         private string? _content = null;
 103
 104         /**
 105          * Creates a new source file.
 106          *
 107          * @param filename source file name
 108          * @param pkg      true if this is a VAPI package file
 109          * @return         newly created source file
 110          */
 111         public SourceFile (CodeContext context, string filename, bool pkg = false, string? content = null) {
 112                 this.filename = filename;
 113                 this.external_package = pkg;
 114                 this.context = context;
 115                 this.content = content;
 116         }
 117
 118         /**
 119          * Adds a new using directive with the specified namespace.
 120          *
 121          * @param ns reference to namespace
 122          */
 123         public void add_using_directive (UsingDirective ns) {
 124                 foreach (UsingDirective using_directive in using_directives) {
 125                         if (same_symbol (using_directive.namespace_symbol, ns.namespace_symbol)) {
 126                                 // ignore duplicates
 127                                 return;
 128                         }
 129                 }
 130                 using_directives.add (ns);
 131         }
 132
 133         public void clear_using_directives () {
 134                 using_directives.clear ();
 135         }
 136
 137         bool same_symbol (Symbol? sym1, Symbol? sym2) {
 138                 if (sym1 == sym2) {
 139                         return true;
 140                 }
 141
 142                 var unresolved_symbol1 = sym1 as UnresolvedSymbol;
 143                 var unresolved_symbol2 = sym2 as UnresolvedSymbol;
 144                 if (unresolved_symbol1 != null && unresolved_symbol2 != null) {
 145                         if (same_symbol (unresolved_symbol1.inner, unresolved_symbol2.inner)) {
 146                                 return (unresolved_symbol1.name == unresolved_symbol2.name);
 147                         }
 148                 }
 149
 150                 return false;
 151         }
 152
 153         /**
 154          * Returns a copy of the list of using directives.
 155          *
 156          * @return using directive list
 157          */
 158         public Gee.List<UsingDirective> get_using_directives () {
 159                 return new ReadOnlyList<UsingDirective> (using_directives);
 160         }
 161
 162         /**
 163          * Adds the specified code node to this source file.
 164          *
 165          * @param node a code node
 166          */
 167         public void add_node (CodeNode node) {
 168                 nodes.add (node);
 169         }
 170
 171         public void remove_node (CodeNode node) {
 172                 nodes.remove (node);
 173         }
 174
 175         /**
 176          * Returns a copy of the list of code nodes.
 177          *
 178          * @return code node list
 179          */
 180         public Gee.List<CodeNode> get_nodes () {
 181                 return new ReadOnlyList<CodeNode> (nodes);
 182         }
 183
 184         public void accept (CodeVisitor visitor) {
 185                 visitor.visit_source_file (this);
 186         }
 187
 188         public void accept_children (CodeVisitor visitor) {
 189                 foreach (UsingDirective ns_ref in using_directives) {
 190                         ns_ref.accept (visitor);
 191                 }
 192
 193                 foreach (CodeNode node in nodes) {
 194                         node.accept (visitor);
 195                 }
 196         }
 197
 198         private string get_subdir () {
 199                 if (context.basedir == null) {
 200                         return "";
 201                 }
 202
 203                 // filename and basedir are already canonicalized
 204                 if (filename.has_prefix (context.basedir)) {
 205                         var basename = Path.get_basename (filename);
 206                         var subdir = filename.substring (context.basedir.len (), filename.len () - context.basedir.len () - basename.len ());
 207                         while (subdir[0] == '/') {
 208                                 subdir = subdir.offset (1);
 209                         }
 210                         return subdir;
 211                 }
 212                 return "";
 213         }
 214
 215         private string get_destination_directory () {
 216                 if (context.directory == null) {
 217                         return get_subdir ();
 218                 }
 219                 return "%s/%s".printf (context.directory, get_subdir ());
 220         }
 221
 222         private string get_basename () {
 223                 long dot = filename.pointer_to_offset (filename.rchr (-1, '.'));
 224                 return Path.get_basename (filename.substring (0, dot));
 225         }
 226
 227         public string get_relative_filename () {
 228                 return get_subdir () + Path.get_basename (filename);
 229         }
 230
 231         /**
 232          * Returns the filename to use when generating C header files.
 233          *
 234          * @return generated C header filename
 235          */
 236         public string get_cheader_filename () {
 237                 if (cheader_filename == null) {
 238                         cheader_filename = "%s%s.h".printf (get_destination_directory (), get_basename ());
 239                 }
 240                 return cheader_filename;
 241         }
 242
 243         /**
 244          * Returns the filename to use when generating C source files.
 245          *
 246          * @return generated C source filename
 247          */
 248         public string get_csource_filename () {
 249                 if (csource_filename == null) {
 250                         csource_filename = "%s%s.c".printf (get_destination_directory (), get_basename ());
 251                 }
 252                 return csource_filename;
 253         }
 254
 255         /**
 256          * Returns the filename to use when including the generated C header
 257          * file.
 258          *
 259          * @return C header filename to include
 260          */
 261         public string get_cinclude_filename () {
 262                 if (cinclude_filename == null) {
 263                         cinclude_filename = "%s%s.h".printf (get_subdir (), get_basename ());
 264                 }
 265                 return cinclude_filename;
 266         }
 267
 268         /**
 269          * Adds the specified symbol to the list of symbols code in this source
 270          * file depends on.
 271          *
 272          * TODO Move source and header file dependency analysis to
 273          * code generator.
 274          *
 275          * @param sym      a symbol
 276          * @param dep_type type of dependency
 277          */
 278         public void add_symbol_dependency (Symbol? sym, SourceFileDependencyType dep_type) {
 279                 if (external_package) {
 280                         return;
 281                 }
 282
 283                 Symbol s;
 284
 285                 if (sym is ErrorCode) {
 286                         s = sym.parent_symbol;
 287                 } else if (sym is TypeSymbol ||
 288                     sym is Method ||
 289                     sym is Field ||
 290                     sym is Property ||
 291                     sym is Constant) {
 292                         s = sym;
 293                 } else if (sym is FormalParameter) {
 294                         var fp = (FormalParameter) sym;
 295                         s = fp.parameter_type.data_type;
 296                         if (s == null) {
 297                                 /* generic type parameter */
 298                                 return;
 299                         }
 300                 } else {
 301                         return;
 302                 }
 303
 304                 if (dep_type == SourceFileDependencyType.SOURCE) {
 305                         source_symbol_dependencies.add (s);
 306                         if (s.external_package) {
 307                                 foreach (string fn in s.get_cheader_filenames ()) {
 308                                         source_external_includes.add (fn);
 309                                 }
 310                         } else {
 311                                 foreach (string fn in s.get_cheader_filenames ()) {
 312                                         source_internal_includes.add (fn);
 313                                 }
 314                         }
 315                         return;
 316                 }
 317
 318                 if (s.external_package) {
 319                         /* external package */
 320                         foreach (string fn in s.get_cheader_filenames ()) {
 321                                 header_external_includes.add (fn);
 322                         }
 323                         return;
 324                 }
 325
 326                 if (dep_type == SourceFileDependencyType.HEADER_FULL) {
 327                         foreach (string fn in s.get_cheader_filenames ()) {
 328                                 header_internal_includes.add (fn);
 329                         }
 330                         header_internal_full_dependencies.add (s.source_reference.file);
 331                 }
 332
 333                 header_internal_dependencies.add (s.source_reference.file);
 334         }
 335
 336         /**
 337          * Adds the symbols that define the specified type to the list of
 338          * symbols code in this source file depends on.
 339          *
 340          * TODO Move source and header file dependency analysis to
 341          * code generator.
 342          *
 343          * @param type     a data type
 344          * @param dep_type type of dependency
 345          */
 346         public void add_type_dependency (DataType type, SourceFileDependencyType dep_type) {
 347                 foreach (Symbol type_symbol in type.get_symbols ()) {
 348                         add_symbol_dependency (type_symbol, dep_type);
 349                 }
 350         }
 351
 352         /**
 353          * Returns the list of external includes the generated C header file
 354          * requires.
 355          *
 356          * @return external include list for C header file
 357          */
 358         public Gee.List<string> get_header_external_includes () {
 359                 return new ReadOnlyList<string> (header_external_includes);
 360         }
 361
 362         /**
 363          * Adds the specified filename to the list of package-internal includes
 364          * the generated C header file requires.
 365          *
 366          * @param include internal include for C header file
 367          */
 368         public void add_header_internal_include (string include) {
 369                 /* skip includes to self */
 370                 if (include != get_cinclude_filename ()) {
 371                         header_internal_includes.add (include);
 372                 }
 373         }
 374
 375         /**
 376          * Returns the list of package-internal includes the generated C header
 377          * file requires.
 378          *
 379          * @return internal include list for C header file
 380          */
 381         public Gee.List<string> get_header_internal_includes () {
 382                 return new ReadOnlyList<string> (header_internal_includes);
 383         }
 384
 385         /**
 386          * Returns the list of external includes the generated C source file
 387          * requires.
 388          *
 389          * @return include list for C source file
 390          */
 391         public Gee.List<string> get_source_external_includes () {
 392                 return new ReadOnlyList<string> (source_external_includes);
 393         }
 394
 395         /**
 396          * Returns the list of package-internal includes the generated C source
 397          * file requires.
 398          *
 399          * @return include list for C source file
 400          */
 401         public Gee.List<string> get_source_internal_includes () {
 402                 return new ReadOnlyList<string> (source_internal_includes);
 403         }
 404
 405         /**
 406          * Returns the list of source files the generated C header file requires
 407          * definitely.
 408          *
 409          * @return definite source file dependencies
 410          */
 411         public Gee.List<weak SourceFile> get_header_internal_full_dependencies () {
 412                 return new ReadOnlyList<weak SourceFile> (header_internal_full_dependencies);
 413         }
 414
 415         /**
 416          * Returns the list of source files the generated C header file loosely
 417          * depends on.
 418          *
 419          * @return loose source file dependencies
 420          */
 421         public Gee.List<weak SourceFile> get_header_internal_dependencies () {
 422                 return new ReadOnlyList<weak SourceFile> (header_internal_dependencies);
 423         }
 424
 425         public Gee.Set<Symbol> get_source_symbol_dependencies () {
 426                 return new ReadOnlySet<Symbol> (source_symbol_dependencies);
 427         }
 428
 429         /**
 430          * Returns the requested line from this file, loading it if needed.
 431          *
 432          * @param lineno 1-based line number
 433          * @return       the specified source line
 434          */
 435         public string? get_source_line (int lineno) {
 436                 if (source_array == null) {
 437                         if (content != null) {
 438                                 read_source_lines (content);
 439                         } else {
 440                                 read_source_file ();
 441                         }
 442                 }
 443                 if (lineno < 1 || lineno > source_array.size) {
 444                         return null;
 445                 }
 446                 return source_array.get (lineno - 1);
 447         }
 448
 449         /**
 450          * Parses the input file into ::source_array.
 451          */
 452         private void read_source_file () {
 453                 string cont;
 454                 try {
 455                         FileUtils.get_contents (filename, out cont);
 456                 } catch (FileError fe) {
 457                         return;
 458                 }
 459                 read_source_lines (cont);
 460         }
 461
 462         private void read_source_lines (string cont)
 463         {
 464                 source_array = new Gee.ArrayList<string> ();
 465                 string[] lines = cont.split ("\n", 0);
 466                 int idx;
 467                 for (idx = 0; lines[idx] != null; ++idx) {
 468                         source_array.add (lines[idx]);
 469                 }
 470         }
 471
 472         public char* get_mapped_contents () {
 473                 if (content != null) {
 474                         return content;
 475                 }
 476
 477                 if (mapped_file == null) {
 478                         try {
 479                                 mapped_file = new MappedFile (filename, false);
 480                         } catch (FileError e) {
 481                                 Report.error (null, "Unable to map file `%s': %s".printf (filename, e.message));
 482                                 return null;
 483                         }
 484                 }
 485
 486                 return mapped_file.get_contents ();
 487         }
 488
 489         public size_t get_mapped_length () {
 490                 if (content != null) {
 491                         return content.length;
 492                 }
 493
 494                 return mapped_file.get_length ();
 495         }
 496
 497         public bool check (SemanticAnalyzer analyzer) {
 498                 foreach (CodeNode node in nodes) {
 499                         node.check (analyzer);
 500                 }
 501                 return true;
 502         }
 503 }
 504
 505 public enum Vala.SourceFileDependencyType {
 506         HEADER_FULL,
 507         HEADER_SHALLOW,
 508         SOURCE
 509 }