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                 writer.write_string (" ");
 122                 writer.write_string (name);
 123                 writer.write_string (" (");
 124
 125                 bool has_args = (CCodeModifiers.PRINTF in modifiers || CCodeModifiers.SCANF in modifiers);
 126                 int i = 0;
 127                 int format_arg_index = -1;
 128                 int args_index = -1;
 129                 foreach (CCodeParameter param in parameters) {
 130                         if (i > 0) {
 131                                 writer.write_string (", ");
 132                         }
 133                         param.write (writer);
 134                         if (CCodeModifiers.FORMAT_ARG in param.modifiers) {
 135                                 format_arg_index = i;
 136                         }
 137                         if (has_args && param.ellipsis) {
 138                                 args_index = i;
 139                         } else if (has_args && param.type_name == "va_list" && format_arg_index < 0) {
 140                                 format_arg_index = i - 1;
 141                         }
 142                         i++;
 143                 }
 144                 if (i == 0) {
 145                         writer.write_string ("void");
 146                 }
 147
 148                 writer.write_string (")");
 149
 150                 if (is_declaration) {
 151                         if (CCodeModifiers.DEPRECATED in modifiers) {
 152                                 writer.write_string (" G_GNUC_DEPRECATED");
 153                         }
 154
 155                         if (CCodeModifiers.PRINTF in modifiers) {
 156                                 format_arg_index = (format_arg_index >= 0 ? format_arg_index + 1 : args_index);
 157                                 writer.write_string (" G_GNUC_PRINTF(%d,%d)".printf (format_arg_index, args_index + 1));
 158                         } else if (CCodeModifiers.SCANF in modifiers) {
 159                                 format_arg_index = (format_arg_index >= 0 ? format_arg_index + 1 : args_index);
 160                                 writer.write_string (" G_GNUC_SCANF(%d,%d)".printf (format_arg_index, args_index + 1));
 161                         } else if (format_arg_index >= 0) {
 162                                 writer.write_string (" G_GNUC_FORMAT(%d)".printf (format_arg_index + 1));
 163                         }
 164
 165                         if (CCodeModifiers.CONST in modifiers) {
 166                                 writer.write_string (" G_GNUC_CONST");
 167                         }
 168                         if (CCodeModifiers.UNUSED in modifiers) {
 169                                 writer.write_string (" G_GNUC_UNUSED");
 170                         }
 171
 172                         if (CCodeModifiers.CONSTRUCTOR in modifiers) {
 173                                 writer.write_string (" __attribute__((constructor))");
 174                         } else if (CCodeModifiers.DESTRUCTOR in modifiers) {
 175                                 writer.write_string (" __attribute__((destructor))");
 176                         }
 177
 178                         writer.write_string (";");
 179                 } else {
 180                         block.write (writer);
 181                         writer.write_newline ();
 182                 }
 183                 writer.write_newline ();
 184         }
 185
 186         public void add_statement (CCodeNode stmt) {
 187                 stmt.line = current_line;
 188                 current_block.add_statement (stmt);
 189         }
 190
 191         public void open_block () {
 192                 statement_stack.add (current_block);
 193                 var parent_block = current_block;
 194
 195                 current_block = new CCodeBlock ();
 196
 197                 parent_block.add_statement (current_block);
 198         }
 199
 200         public void open_if (CCodeExpression condition) {
 201                 statement_stack.add (current_block);
 202                 var parent_block = current_block;
 203
 204                 current_block = new CCodeBlock ();
 205
 206                 var cif = new CCodeIfStatement (condition, current_block);
 207                 cif.line = current_line;
 208                 statement_stack.add (cif);
 209
 210                 parent_block.add_statement (cif);
 211         }
 212
 213         public void add_else () {
 214                 current_block = new CCodeBlock ();
 215
 216                 var cif = (CCodeIfStatement) statement_stack[statement_stack.size - 1];
 217                 cif.line = current_line;
 218                 assert (cif.false_statement == null);
 219                 cif.false_statement = current_block;
 220         }
 221
 222         public void else_if (CCodeExpression condition) {
 223                 var parent_if = (CCodeIfStatement) statement_stack[statement_stack.size - 1];
 224                 assert (parent_if.false_statement == null);
 225
 226                 statement_stack.remove_at (statement_stack.size - 1);
 227
 228                 current_block = new CCodeBlock ();
 229
 230                 var cif = new CCodeIfStatement (condition, current_block);
 231                 cif.line = current_line;
 232                 parent_if.false_statement = cif;
 233                 statement_stack.add (cif);
 234         }
 235
 236         public void open_while (CCodeExpression condition) {
 237                 statement_stack.add (current_block);
 238                 var parent_block = current_block;
 239
 240                 current_block = new CCodeBlock ();
 241
 242                 var cwhile = new CCodeWhileStatement (condition, current_block);
 243                 cwhile.line = current_line;
 244                 parent_block.add_statement (cwhile);
 245         }
 246
 247         public void open_for (CCodeExpression? initializer, CCodeExpression condition, CCodeExpression? iterator) {
 248                 statement_stack.add (current_block);
 249                 var parent_block = current_block;
 250
 251                 current_block = new CCodeBlock ();
 252
 253                 var cfor = new CCodeForStatement (condition, current_block);
 254                 cfor.line = current_line;
 255                 if (initializer != null) {
 256                         cfor.add_initializer (initializer);
 257                 }
 258                 if (iterator != null) {
 259                         cfor.add_iterator (iterator);
 260                 }
 261
 262                 parent_block.add_statement (cfor);
 263         }
 264
 265         public void open_switch (CCodeExpression expression) {
 266                 statement_stack.add (current_block);
 267                 var parent_block = current_block;
 268
 269                 var cswitch = new CCodeSwitchStatement (expression);
 270                 cswitch.line = current_line;
 271                 current_block = cswitch;
 272
 273                 parent_block.add_statement (cswitch);
 274         }
 275
 276         public void add_label (string label) {
 277                 add_statement (new CCodeLabel (label));
 278         }
 279
 280         public void add_case (CCodeExpression expression) {
 281                 add_statement (new CCodeCaseStatement (expression));
 282         }
 283
 284         public void add_default () {
 285                 add_statement (new CCodeLabel ("default"));
 286         }
 287
 288         public void add_goto (string target) {
 289                 add_statement (new CCodeGotoStatement (target));
 290         }
 291
 292         public void add_expression (CCodeExpression expression) {
 293                 add_statement (new CCodeExpressionStatement (expression));
 294         }
 295
 296         public void add_assignment (CCodeExpression left, CCodeExpression right) {
 297                 add_expression (new CCodeAssignment (left, right));
 298         }
 299
 300         public void add_return (CCodeExpression? expression = null) {
 301                 add_statement (new CCodeReturnStatement (expression));
 302         }
 303
 304         public void add_break () {
 305                 add_statement (new CCodeBreakStatement ());
 306         }
 307
 308         public void add_continue () {
 309                 add_statement (new CCodeContinueStatement ());
 310         }
 311
 312         public void add_declaration (string type_name, CCodeDeclarator declarator, CCodeModifiers modifiers = 0) {
 313                 var stmt = new CCodeDeclaration (type_name);
 314                 stmt.add_declarator (declarator);
 315                 stmt.modifiers = modifiers;
 316                 add_statement (stmt);
 317         }
 318
 319         public void close () {
 320                 do {
 321                         var top = statement_stack[statement_stack.size - 1];
 322                         statement_stack.remove_at (statement_stack.size - 1);
 323                         current_block = top as CCodeBlock;
 324                 } while (current_block == null);
 325         }
 326 }