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