ccode/valaccodefunction.vala

   1 /* valaccodefunction.vala
   2  *
   3  * Copyright (C) 2006-2012  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 function declaration in the C code.
  27  */
  28 public class Vala.CCodeFunction : CCodeNode {
  29         /**
  30          * The name of this function.
  31          */
  32         public string name { get; set; }
  33
  34         /**
  35          * The function return type.
  36          */
  37         public string return_type { get; set; }
  38
  39         public bool is_declaration { get; set; }
  40
  41         /**
  42          * The function body.
  43          */
  44         public CCodeBlock block { get; set; }
  45
  46         /**
  47          * The current line directive.
  48          */
  49         public CCodeLineDirective current_line { get; set; }
  50
  51         /**
  52          * The current block to be written into.
  53          */
  54         public CCodeBlock current_block { get; set; }
  55
  56         private List<CCodeParameter> parameters = new ArrayList<CCodeParameter> ();
  57
  58         List<CCodeStatement> statement_stack = new ArrayList<CCodeStatement> ();
  59
  60         public CCodeFunction (string name, string return_type = "void") {
  61                 this.name = name;
  62                 this.return_type = return_type;
  63                 this.block = new CCodeBlock ();
  64                 current_block = block;
  65         }
  66
  67         /**
  68          * Appends the specified parameter to the list of function parameters.
  69          *
  70          * @param param a formal parameter
  71          */
  72         public void add_parameter (CCodeParameter param) {
  73                 parameters.add (param);
  74         }
  75
  76         public void insert_parameter (int position, CCodeParameter param) {
  77                 parameters.insert (position, param);
  78         }
  79
  80         public int get_parameter_count () {
  81                 return parameters.size;
  82         }
  83
  84         public CCodeParameter get_parameter (int position) {
  85                 return parameters[position];
  86         }
  87
  88         /**
  89          * Returns a copy of this function.
  90          *
  91          * @return copied function
  92          */
  93         public CCodeFunction copy () {
  94                 var func = new CCodeFunction (name, return_type);
  95                 func.modifiers = modifiers;
  96
  97                 /* no deep copy for lists available yet
  98                  * func.parameters = parameters.copy ();
  99                  */
 100                 foreach (CCodeParameter param in parameters) {
 101                         func.parameters.add (param);
 102                 }
 103
 104                 func.is_declaration = is_declaration;
 105                 func.block = block;
 106                 return func;
 107         }
 108
 109         public override void write (CCodeWriter writer) {
 110                 writer.write_indent (line);
 111                 if (CCodeModifiers.INTERNAL in modifiers) {
 112                         writer.write_string ("G_GNUC_INTERNAL ");
 113                 }
 114                 if (CCodeModifiers.STATIC in modifiers) {
 115                         writer.write_string ("static ");
 116                 }
 117                 if (CCodeModifiers.INLINE in modifiers) {
 118                         writer.write_string ("inline ");
 119                 }
 120                 writer.write_string (return_type);
 121                 if (is_declaration) {
 122                         writer.write_string (" ");
 123                 } else {
 124                         writer.write_newline ();
 125                 }
 126                 writer.write_string (name);
 127                 writer.write_string (" (");
 128                 int param_pos_begin = (is_declaration ? return_type.char_count () + 1 : 0 ) + name.char_count () + 2;
 129
 130                 bool has_args = (CCodeModifiers.PRINTF in modifiers || CCodeModifiers.SCANF in modifiers);
 131                 int i = 0;
 132                 int format_arg_index = -1;
 133                 int args_index = -1;
 134                 foreach (CCodeParameter param in parameters) {
 135                         if (i > 0) {
 136                                 writer.write_string (",");
 137                                 writer.write_newline ();
 138                                 writer.write_nspaces (param_pos_begin);
 139                         }
 140                         param.write (writer);
 141                         if (CCodeModifiers.FORMAT_ARG in param.modifiers) {
 142                                 format_arg_index = i;
 143                         }
 144                         if (has_args && param.ellipsis) {
 145                                 args_index = i;
 146                         } else if (has_args && param.type_name == "va_list" && format_arg_index < 0) {
 147                                 format_arg_index = i - 1;
 148                         }
 149                         i++;
 150                 }
 151                 if (i == 0) {
 152                         writer.write_string ("void");
 153                 }
 154
 155                 writer.write_string (")");
 156
 157                 if (is_declaration) {
 158                         if (CCodeModifiers.DEPRECATED in modifiers) {
 159                                 writer.write_string (" G_GNUC_DEPRECATED");
 160                         }
 161
 162                         if (CCodeModifiers.PRINTF in modifiers) {
 163                                 format_arg_index = (format_arg_index >= 0 ? format_arg_index + 1 : args_index);
 164                                 writer.write_string (" G_GNUC_PRINTF(%d,%d)".printf (format_arg_index, args_index + 1));
 165                         } else if (CCodeModifiers.SCANF in modifiers) {
 166                                 format_arg_index = (format_arg_index >= 0 ? format_arg_index + 1 : args_index);
 167                                 writer.write_string (" G_GNUC_SCANF(%d,%d)".printf (format_arg_index, args_index + 1));
 168                         } else if (format_arg_index >= 0) {
 169                                 writer.write_string (" G_GNUC_FORMAT(%d)".printf (format_arg_index + 1));
 170                         }
 171
 172                         if (CCodeModifiers.CONST in modifiers) {
 173                                 writer.write_string (" G_GNUC_CONST");
 174                         }
 175                         if (CCodeModifiers.UNUSED in modifiers) {
 176                                 writer.write_string (" G_GNUC_UNUSED");
 177                         }
 178
 179                         if (CCodeModifiers.CONSTRUCTOR in modifiers) {
 180                                 writer.write_string (" __attribute__((constructor))");
 181                         } else if (CCodeModifiers.DESTRUCTOR in modifiers) {
 182                                 writer.write_string (" __attribute__((destructor))");
 183                         }
 184
 185                         writer.write_string (";");
 186                 } else {
 187                         writer.write_newline ();
 188                         block.write (writer);
 189                         writer.write_newline ();
 190                 }
 191                 writer.write_newline ();
 192         }
 193
 194         public void add_statement (CCodeNode stmt) {
 195                 stmt.line = current_line;
 196                 current_block.add_statement (stmt);
 197         }
 198
 199         public void open_block () {
 200                 statement_stack.add (current_block);
 201                 var parent_block = current_block;
 202
 203                 current_block = new CCodeBlock ();
 204
 205                 parent_block.add_statement (current_block);
 206         }
 207
 208         public void open_if (CCodeExpression condition) {
 209                 statement_stack.add (current_block);
 210                 var parent_block = current_block;
 211
 212                 current_block = new CCodeBlock ();
 213
 214                 var cif = new CCodeIfStatement (condition, current_block);
 215                 cif.line = current_line;
 216                 statement_stack.add (cif);
 217
 218                 parent_block.add_statement (cif);
 219         }
 220
 221         public void add_else () {
 222                 current_block = new CCodeBlock ();
 223
 224                 var cif = (CCodeIfStatement) statement_stack[statement_stack.size - 1];
 225                 cif.line = current_line;
 226                 assert (cif.false_statement == null);
 227                 cif.false_statement = current_block;
 228         }
 229
 230         public void else_if (CCodeExpression condition) {
 231                 var parent_if = (CCodeIfStatement) statement_stack.remove_at (statement_stack.size - 1);
 232                 assert (parent_if.false_statement == null);
 233
 234                 current_block = new CCodeBlock ();
 235
 236                 var cif = new CCodeIfStatement (condition, current_block);
 237                 cif.line = current_line;
 238                 parent_if.false_statement = cif;
 239                 statement_stack.add (cif);
 240         }
 241
 242         public void open_while (CCodeExpression condition) {
 243                 statement_stack.add (current_block);
 244                 var parent_block = current_block;
 245
 246                 current_block = new CCodeBlock ();
 247
 248                 var cwhile = new CCodeWhileStatement (condition, current_block);
 249                 cwhile.line = current_line;
 250                 parent_block.add_statement (cwhile);
 251         }
 252
 253         public void open_for (CCodeExpression? initializer, CCodeExpression condition, CCodeExpression? iterator) {
 254                 statement_stack.add (current_block);
 255                 var parent_block = current_block;
 256
 257                 current_block = new CCodeBlock ();
 258
 259                 var cfor = new CCodeForStatement (condition, current_block);
 260                 cfor.line = current_line;
 261                 if (initializer != null) {
 262                         cfor.add_initializer (initializer);
 263                 }
 264                 if (iterator != null) {
 265                         cfor.add_iterator (iterator);
 266                 }
 267
 268                 parent_block.add_statement (cfor);
 269         }
 270
 271         public void open_switch (CCodeExpression expression) {
 272                 statement_stack.add (current_block);
 273                 var parent_block = current_block;
 274
 275                 var cswitch = new CCodeSwitchStatement (expression);
 276                 cswitch.line = current_line;
 277                 current_block = cswitch;
 278
 279                 parent_block.add_statement (cswitch);
 280         }
 281
 282         public void add_label (string label) {
 283                 add_statement (new CCodeLabel (label));
 284         }
 285
 286         public void add_case (CCodeExpression expression) {
 287                 add_statement (new CCodeCaseStatement (expression));
 288         }
 289
 290         public void add_default () {
 291                 add_statement (new CCodeLabel ("default"));
 292         }
 293
 294         public void add_goto (string target) {
 295                 add_statement (new CCodeGotoStatement (target));
 296         }
 297
 298         public void add_expression (CCodeExpression expression) {
 299                 add_statement (new CCodeExpressionStatement (expression));
 300         }
 301
 302         public void add_assignment (CCodeExpression left, CCodeExpression right) {
 303                 add_expression (new CCodeAssignment (left, right));
 304         }
 305
 306         public void add_return (CCodeExpression? expression = null) {
 307                 add_statement (new CCodeReturnStatement (expression));
 308         }
 309
 310         public void add_break () {
 311                 add_statement (new CCodeBreakStatement ());
 312         }
 313
 314         public void add_continue () {
 315                 add_statement (new CCodeContinueStatement ());
 316         }
 317
 318         public void add_declaration (string type_name, CCodeDeclarator declarator, CCodeModifiers modifiers = 0) {
 319                 var stmt = new CCodeDeclaration (type_name);
 320                 stmt.add_declarator (declarator);
 321                 stmt.modifiers = modifiers;
 322                 add_statement (stmt);
 323         }
 324
 325         public void close () {
 326                 do {
 327                         var top = statement_stack.remove_at (statement_stack.size - 1);
 328                         current_block = top as CCodeBlock;
 329                 } while (current_block == null);
 330         }
 331 }