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                         }
 142                 }
 143         }
 144
 145         /**
 146          * Writes tabs according to the current indent level.
 147          */
 148         public void write_indent (CCodeLineDirective? line = null) {
 149                 if (line_directives) {
 150                         if (line != null) {
 151                                 line.write (this);
 152                                 using_line_directive = true;
 153                         } else if (using_line_directive) {
 154                                 // no corresponding Vala line, emit line directive for C line
 155                                 write_string ("#line %d \"%s\"".printf (current_line_number + 1, Path.get_basename (filename)));
 156                                 write_newline ();
 157                                 using_line_directive = false;
 158                         }
 159                 }
 160
 161                 if (!_bol) {
 162                         write_newline ();
 163                 }
 164
 165                 stream.puts (string.nfill (indent, '\t'));
 166                 _bol = false;
 167         }
 168
 169         /**
 170          * Writes the specified string.
 171          *
 172          * @param s a string
 173          */
 174         public void write_string (string s) {
 175                 stream.puts (s);
 176                 _bol = false;
 177         }
 178
 179         /**
 180          * Writes a newline.
 181          */
 182         public void write_newline () {
 183                 stream.putc ('\n');
 184                 current_line_number++;
 185                 _bol = true;
 186         }
 187
 188         /**
 189          * Opens a new block, increasing the indent level.
 190          */
 191         public void write_begin_block () {
 192                 if (!_bol) {
 193                         stream.putc (' ');
 194                 } else {
 195                         write_indent ();
 196                 }
 197                 stream.putc ('{');
 198                 write_newline ();
 199                 indent++;
 200         }
 201
 202         /**
 203          * Closes the current block, decreasing the indent level.
 204          */
 205         public void write_end_block () {
 206                 assert (indent > 0);
 207
 208                 indent--;
 209                 write_indent ();
 210                 stream.putc ('}');
 211         }
 212
 213         /**
 214          * Writes the specified text as comment.
 215          *
 216          * @param text the comment text
 217          */
 218         public void write_comment (string text) {
 219                 try {
 220                         write_indent ();
 221                         stream.puts ("/*");
 222                         bool first = true;
 223
 224                         // discard tabs at beginning of line
 225                         if (fix_indent_regex == null)
 226                                 fix_indent_regex = new GLib.Regex ("^\t+");;
 227
 228                         foreach (unowned string line in text.split ("\n")) {
 229                                 if (!first) {
 230                                         write_indent ();
 231                                 } else {
 232                                         first = false;
 233                                 }
 234
 235                                 var lineparts = fix_indent_regex.replace_literal (line, -1, 0, "").split ("*/");
 236
 237                                 for (int i = 0; lineparts[i] != null; i++) {
 238                                         stream.puts (lineparts[i]);
 239                                         if (lineparts[i+1] != null) {
 240                                                 stream.puts ("* /");
 241                                         }
 242                                 }
 243                         }
 244                         stream.puts ("*/");
 245                         write_newline ();
 246                 } catch (RegexError e) {
 247                         // ignore
 248                 }
 249         }
 250 }