ccode/valaccodewriter.vala

   1 /* valaccodewriter.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 writer to write C source files.
  27  */
  28 public class Vala.CCodeWriter {
  29         /**
  30          * Specifies the file to be written.
  31          */
  32         public string filename { get; set; }
  33
  34         /**
  35          * Specifies the source file used to generate this one.
  36          */
  37         private string source_filename;
  38
  39         /**
  40          * Specifies whether to emit line directives.
  41          */
  42         public bool line_directives { get; set; }
  43
  44         /**
  45          * Specifies whether the output stream is at the beginning of a line.
  46          */
  47         public bool bol {
  48                 get { return _bol; }
  49         }
  50
  51         static GLib.Regex fix_indent_regex;
  52
  53         private string temp_filename;
  54         private bool file_exists;
  55
  56         private FileStream? stream;
  57
  58         private int indent;
  59         private int current_line_number = 1;
  60         private bool using_line_directive;
  61
  62         /* at begin of line */
  63         private bool _bol = true;
  64
  65         public CCodeWriter (string filename, string? source_filename = null) {
  66                 this.filename = filename;
  67                 this.source_filename = source_filename;
  68         }
  69
  70         /**
  71          * Opens the file.
  72          *
  73          * @return true if the file has been opened successfully,
  74          *         false otherwise
  75          */
  76         public bool open (bool write_version) {
  77                 file_exists = FileUtils.test (filename, FileTest.EXISTS);
  78                 if (file_exists) {
  79                         temp_filename = "%s.valatmp".printf (filename);
  80                         stream = FileStream.open (temp_filename, "w");
  81                 } else {
  82                         /*
  83                          * File doesn't exist. In case of a particular destination (-d flag),
  84                          * check and create the directory structure.
  85                          */
  86                         var dirname = Path.get_dirname (filename);
  87                         DirUtils.create_with_parents (dirname, 0755);
  88                         stream = FileStream.open (filename, "w");
  89                 }
  90
  91                 if (stream == null) {
  92                         return false;
  93                 }
  94
  95                 var opening = write_version ?
  96                         "/* %s generated by valac %s, the Vala compiler".printf (Path.get_basename (filename), Config.BUILD_VERSION) :
  97                         "/* %s generated by valac, the Vala compiler".printf (Path.get_basename (filename));
  98                 write_string (opening);
  99
 100                 // Write the file name if known
 101                 if (source_filename != null) {
 102                         write_newline ();
 103                         write_string (" * generated from %s".printf (Path.get_basename (source_filename)));
 104                 }
 105
 106                 write_string (", do not modify */");
 107                 write_newline ();
 108                 write_newline ();
 109
 110                 return true;
 111         }
 112
 113         /**
 114          * Closes the file.
 115          */
 116         public void close () {
 117                 stream = null;
 118
 119                 if (file_exists) {
 120                         var changed = true;
 121
 122                         try {
 123                                 var old_file = new MappedFile (filename, false);
 124                                 var new_file = new MappedFile (temp_filename, false);
 125                                 var len = old_file.get_length ();
 126                                 if (len == new_file.get_length ()) {
 127                                         if (Memory.cmp (old_file.get_contents (), new_file.get_contents (), len) == 0) {
 128                                                 changed = false;
 129                                         }
 130                                 }
 131                                 old_file = null;
 132                                 new_file = null;
 133                         } catch (FileError e) {
 134                                 // assume changed if mmap comparison doesn't work
 135                         }
 136
 137                         if (changed) {
 138                                 FileUtils.rename (temp_filename, filename);
 139                         } else {
 140                                 FileUtils.unlink (temp_filename);
 141                                 if (source_filename != null) {
 142                                         var stats = Stat (source_filename);
 143                                         var target_stats = Stat (filename);
 144                                         if (stats.st_mtime >= target_stats.st_mtime) {
 145                                                 UTimBuf timebuf = { stats.st_atime + 1, stats.st_mtime + 1 };
 146                                                 FileUtils.utime (filename, timebuf);
 147                                         }
 148                                 }
 149                         }
 150                 }
 151         }
 152
 153         /**
 154          * Writes tabs according to the current indent level.
 155          */
 156         public void write_indent (CCodeLineDirective? line = null) {
 157                 if (line_directives) {
 158                         if (line != null) {
 159                                 line.write (this);
 160                                 using_line_directive = true;
 161                         } else if (using_line_directive) {
 162                                 // no corresponding Vala line, emit line directive for C line
 163                                 write_string ("#line %d \"%s\"".printf (current_line_number + 1, Path.get_basename (filename)));
 164                                 write_newline ();
 165                                 using_line_directive = false;
 166                         }
 167                 }
 168
 169                 if (!_bol) {
 170                         write_newline ();
 171                 }
 172
 173                 stream.puts (string.nfill (indent, '\t'));
 174                 _bol = false;
 175         }
 176
 177         /**
 178          * Writes n spaces.
 179          */
 180         public void write_nspaces (uint n) {
 181                 stream.puts (string.nfill (n, ' '));
 182         }
 183
 184         /**
 185          * Writes the specified string.
 186          *
 187          * @param s a string
 188          */
 189         public void write_string (string s) {
 190                 stream.puts (s);
 191                 _bol = false;
 192         }
 193
 194         /**
 195          * Writes a newline.
 196          */
 197         public void write_newline () {
 198                 stream.putc ('\n');
 199                 current_line_number++;
 200                 _bol = true;
 201         }
 202
 203         /**
 204          * Opens a new block, increasing the indent level.
 205          */
 206         public void write_begin_block () {
 207                 if (!_bol) {
 208                         stream.putc (' ');
 209                 } else {
 210                         write_indent ();
 211                 }
 212                 stream.putc ('{');
 213                 write_newline ();
 214                 indent++;
 215         }
 216
 217         /**
 218          * Closes the current block, decreasing the indent level.
 219          */
 220         public void write_end_block () {
 221                 assert (indent > 0);
 222
 223                 indent--;
 224                 write_indent ();
 225                 stream.putc ('}');
 226         }
 227
 228         /**
 229          * Writes the specified text as comment.
 230          *
 231          * @param text the comment text
 232          */
 233         public void write_comment (string text) {
 234                 try {
 235                         write_indent ();
 236                         stream.puts ("/*");
 237                         bool first = true;
 238
 239                         // discard tabs at beginning of line
 240                         if (fix_indent_regex == null)
 241                                 fix_indent_regex = new GLib.Regex ("^\t+");;
 242
 243                         foreach (unowned string line in text.split ("\n")) {
 244                                 if (!first) {
 245                                         write_indent ();
 246                                 } else {
 247                                         first = false;
 248                                 }
 249
 250                                 var lineparts = fix_indent_regex.replace_literal (line, -1, 0, "").split ("*/");
 251
 252                                 for (int i = 0; lineparts[i] != null; i++) {
 253                                         stream.puts (lineparts[i]);
 254                                         if (lineparts[i+1] != null) {
 255                                                 stream.puts ("* /");
 256                                         }
 257                                 }
 258                         }
 259                         stream.puts ("*/");
 260                         write_newline ();
 261                 } catch (RegexError e) {
 262                         // ignore
 263                 }
 264         }
 265 }