vala/valasourcefile.vala

   1 /* valasourcefile.vala
   2  *
   3  * Copyright (C) 2006-2009  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  * Represents a Vala source or VAPI package file.
  27  */
  28 public class Vala.SourceFile {
  29         /**
  30          * The name of this source file.
  31          */
  32         public string filename { get; set; }
  33
  34
  35         /**
  36          * Specifies whether this file is a VAPI package file.
  37          */
  38         public bool external_package { get; set; }
  39
  40         /**
  41          * The context this source file belongs to.
  42          */
  43         public weak CodeContext context { get; set; }
  44
  45         public string? content {
  46                 get { return this._content; }
  47                 set {
  48                         this._content = value;
  49                         this.source_array = null;
  50                 }
  51         }
  52
  53         private ArrayList<Comment> comments = new ArrayList<Comment> ();
  54
  55         public List<UsingDirective> current_using_directives { get; set; default = new ArrayList<UsingDirective> (); }
  56
  57         private List<CodeNode> nodes = new ArrayList<CodeNode> ();
  58
  59         private string csource_filename = null;
  60         private string cinclude_filename = null;
  61
  62         private ArrayList<string> source_array = null;
  63
  64         private MappedFile mapped_file = null;
  65
  66         private string? _content = null;
  67
  68         /**
  69          * Creates a new source file.
  70          *
  71          * @param filename source file name
  72          * @param pkg      true if this is a VAPI package file
  73          * @return         newly created source file
  74          */
  75         public SourceFile (CodeContext context, string filename, bool pkg = false, string? content = null) {
  76                 this.filename = filename;
  77                 this.external_package = pkg;
  78                 this.context = context;
  79                 this.content = content;
  80         }
  81
  82         /**
  83          * Adds a header comment to this source file.
  84          */
  85         public void add_comment (Comment comment) {
  86                 comments.add (comment);
  87         }
  88
  89         /**
  90          * Returns a copy of the list of header comments.
  91          *
  92          * @return list of comments
  93          */
  94         public List<Comment> get_comments () {
  95                 return new ReadOnlyList<Comment> (comments);
  96         }
  97
  98         /**
  99          * Adds a new using directive with the specified namespace.
 100          *
 101          * @param ns reference to namespace
 102          */
 103         public void add_using_directive (UsingDirective ns) {
 104                 // do not modify current_using_directives, it should be considered immutable
 105                 // for correct symbol resolving
 106                 var old_using_directives = current_using_directives;
 107                 current_using_directives = new ArrayList<UsingDirective> ();
 108                 foreach (var using_directive in old_using_directives) {
 109                         current_using_directives.add (using_directive);
 110                 }
 111                 current_using_directives.add (ns);
 112         }
 113
 114         /**
 115          * Adds the specified code node to this source file.
 116          *
 117          * @param node a code node
 118          */
 119         public void add_node (CodeNode node) {
 120                 nodes.add (node);
 121         }
 122
 123         public void remove_node (CodeNode node) {
 124                 nodes.remove (node);
 125         }
 126
 127         /**
 128          * Returns a copy of the list of code nodes.
 129          *
 130          * @return code node list
 131          */
 132         public List<CodeNode> get_nodes () {
 133                 return new ReadOnlyList<CodeNode> (nodes);
 134         }
 135
 136         public void accept (CodeVisitor visitor) {
 137                 visitor.visit_source_file (this);
 138         }
 139
 140         public void accept_children (CodeVisitor visitor) {
 141                 foreach (CodeNode node in nodes) {
 142                         node.accept (visitor);
 143                 }
 144         }
 145
 146         private string get_subdir () {
 147                 if (context.basedir == null) {
 148                         return "";
 149                 }
 150
 151                 // filename and basedir are already canonicalized
 152                 if (filename.has_prefix (context.basedir + "/")) {
 153                         var basename = Path.get_basename (filename);
 154                         var subdir = filename.substring (context.basedir.len (), filename.len () - context.basedir.len () - basename.len ());
 155                         while (subdir[0] == '/') {
 156                                 subdir = subdir.offset (1);
 157                         }
 158                         return subdir;
 159                 }
 160                 return "";
 161         }
 162
 163         private string get_destination_directory () {
 164                 if (context.directory == null) {
 165                         return get_subdir ();
 166                 }
 167                 return "%s/%s".printf (context.directory, get_subdir ());
 168         }
 169
 170         private string get_basename () {
 171                 long dot = filename.pointer_to_offset (filename.rchr (-1, '.'));
 172                 return Path.get_basename (filename.substring (0, dot));
 173         }
 174
 175         public string get_relative_filename () {
 176                 return get_subdir () + Path.get_basename (filename);
 177         }
 178
 179         /**
 180          * Returns the filename to use when generating C source files.
 181          *
 182          * @return generated C source filename
 183          */
 184         public string get_csource_filename () {
 185                 if (csource_filename == null) {
 186                         if (context.ccode_only || context.save_csources) {
 187                                 csource_filename = "%s%s.c".printf (get_destination_directory (), get_basename ());
 188                         } else {
 189                                 // temporary file
 190                                 csource_filename = "%s%s.vala.c".printf (get_destination_directory (), get_basename ());
 191                         }
 192                 }
 193                 return csource_filename;
 194         }
 195
 196         /**
 197          * Returns the filename to use when including the generated C header
 198          * file.
 199          *
 200          * @return C header filename to include
 201          */
 202         public string get_cinclude_filename () {
 203                 if (cinclude_filename == null) {
 204                         if (context.header_filename != null) {
 205                                 cinclude_filename = Path.get_basename (context.header_filename);
 206                                 if (context.includedir != null) {
 207                                         cinclude_filename = "%s/%s".printf (context.includedir, cinclude_filename);
 208                                 }
 209                         } else {
 210                                 cinclude_filename = "%s%s.h".printf (get_subdir (), get_basename ());
 211                         }
 212                 }
 213                 return cinclude_filename;
 214         }
 215
 216         /**
 217          * Returns the requested line from this file, loading it if needed.
 218          *
 219          * @param lineno 1-based line number
 220          * @return       the specified source line
 221          */
 222         public string? get_source_line (int lineno) {
 223                 if (source_array == null) {
 224                         if (content != null) {
 225                                 read_source_lines (content);
 226                         } else {
 227                                 read_source_file ();
 228                         }
 229                 }
 230                 if (lineno < 1 || lineno > source_array.size) {
 231                         return null;
 232                 }
 233                 return source_array.get (lineno - 1);
 234         }
 235
 236         /**
 237          * Parses the input file into ::source_array.
 238          */
 239         private void read_source_file () {
 240                 string cont;
 241                 try {
 242                         FileUtils.get_contents (filename, out cont);
 243                 } catch (FileError fe) {
 244                         return;
 245                 }
 246                 read_source_lines (cont);
 247         }
 248
 249         private void read_source_lines (string cont)
 250         {
 251                 source_array = new ArrayList<string> ();
 252                 string[] lines = cont.split ("\n", 0);
 253                 int idx;
 254                 for (idx = 0; lines[idx] != null; ++idx) {
 255                         source_array.add (lines[idx]);
 256                 }
 257         }
 258
 259         public char* get_mapped_contents () {
 260                 if (content != null) {
 261                         return (char*) content;
 262                 }
 263
 264                 if (mapped_file == null) {
 265                         try {
 266                                 mapped_file = new MappedFile (filename, false);
 267                         } catch (FileError e) {
 268                                 Report.error (null, "Unable to map file `%s': %s".printf (filename, e.message));
 269                                 return null;
 270                         }
 271                 }
 272
 273                 return mapped_file.get_contents ();
 274         }
 275
 276         public size_t get_mapped_length () {
 277                 if (content != null) {
 278                         return content.length;
 279                 }
 280
 281                 return mapped_file.get_length ();
 282         }
 283
 284         public bool check (SemanticAnalyzer analyzer) {
 285                 foreach (CodeNode node in nodes) {
 286                         node.check (analyzer);
 287                 }
 288                 return true;
 289         }
 290 }
 291