ccode/valaccodefunction.vala

   1 /* valaccodefunction.vala
   2  *
   3  * Copyright (C) 2006-2010  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 modifiers.
  36          */
  37         public CCodeModifiers modifiers { get; set; }
  38
  39         /**
  40          * The function return type.
  41          */
  42         public string return_type { get; set; }
  43
  44         public string attributes { get; set; }
  45
  46         public bool is_declaration { get; set; }
  47
  48         /**
  49          * The function body.
  50          */
  51         public CCodeBlock block { get; set; }
  52
  53         private List<CCodeParameter> parameters = new ArrayList<CCodeParameter> ();
  54
  55         CCodeBlock current_block;
  56         List<CCodeStatement> statement_stack = new ArrayList<CCodeStatement> ();
  57
  58         public CCodeFunction (string name, string return_type = "void") {
  59                 this.name = name;
  60                 this.return_type = return_type;
  61                 this.block = new CCodeBlock ();
  62                 current_block = block;
  63         }
  64
  65         /**
  66          * Appends the specified parameter to the list of function parameters.
  67          *
  68          * @param param a formal parameter
  69          */
  70         public void add_parameter (CCodeParameter param) {
  71                 parameters.add (param);
  72         }
  73
  74         public void insert_parameter (int position, CCodeParameter param) {
  75                 parameters.insert (position, param);
  76         }
  77
  78         /**
  79          * Returns a copy of this function.
  80          *
  81          * @return copied function
  82          */
  83         public CCodeFunction copy () {
  84                 var func = new CCodeFunction (name, return_type);
  85                 func.modifiers = modifiers;
  86                 func.attributes = attributes;
  87
  88                 /* no deep copy for lists available yet
  89                  * func.parameters = parameters.copy ();
  90                  */
  91                 foreach (CCodeParameter param in parameters) {
  92                         func.parameters.add (param);
  93                 }
  94
  95                 func.is_declaration = is_declaration;
  96                 func.block = block;
  97                 return func;
  98         }
  99
 100         public override void write (CCodeWriter writer) {
 101                 writer.write_indent (line);
 102                 if (CCodeModifiers.STATIC in modifiers) {
 103                         writer.write_string ("static ");
 104                 }
 105                 if (CCodeModifiers.INLINE in modifiers) {
 106                         writer.write_string ("inline ");
 107                 }
 108                 writer.write_string (return_type);
 109                 writer.write_string (" ");
 110                 writer.write_string (name);
 111                 writer.write_string (" (");
 112
 113                 bool first = true;
 114                 foreach (CCodeParameter param in parameters) {
 115                         if (!first) {
 116                                 writer.write_string (", ");
 117                         } else {
 118                                 first = false;
 119                         }
 120                         param.write (writer);
 121                 }
 122                 if (first) {
 123                         writer.write_string ("void");
 124                 }
 125
 126                 writer.write_string (")");
 127
 128                 if (CCodeModifiers.DEPRECATED in modifiers) {
 129                         writer.write_string (" G_GNUC_DEPRECATED");
 130                 }
 131
 132                 if (is_declaration) {
 133                         if (attributes != null) {
 134                                 writer.write_string (" ");
 135                                 writer.write_string (attributes);
 136                         }
 137
 138                         writer.write_string (";");
 139                 } else {
 140                         block.write (writer);
 141                         writer.write_newline ();
 142                 }
 143                 writer.write_newline ();
 144         }
 145
 146         public void add_statement (CCodeNode stmt) {
 147                 current_block.add_statement (stmt);
 148         }
 149
 150         public void open_block () {
 151                 statement_stack.add (current_block);
 152                 var parent_block = current_block;
 153
 154                 current_block = new CCodeBlock ();
 155
 156                 parent_block.add_statement (current_block);
 157         }
 158
 159         public void open_if (CCodeExpression condition) {
 160                 statement_stack.add (current_block);
 161                 var parent_block = current_block;
 162
 163                 current_block = new CCodeBlock ();
 164
 165                 var cif = new CCodeIfStatement (condition, current_block);
 166                 statement_stack.add (cif);
 167
 168                 parent_block.add_statement (cif);
 169         }
 170
 171         public void add_else () {
 172                 current_block = new CCodeBlock ();
 173
 174                 var cif = (CCodeIfStatement) statement_stack[statement_stack.size - 1];
 175                 assert (cif.false_statement == null);
 176                 cif.false_statement = current_block;
 177         }
 178
 179         public void else_if (CCodeExpression condition) {
 180                 var parent_if = (CCodeIfStatement) statement_stack[statement_stack.size - 1];
 181                 assert (parent_if.false_statement == null);
 182
 183                 statement_stack.remove_at (statement_stack.size - 1);
 184
 185                 current_block = new CCodeBlock ();
 186
 187                 var cif = new CCodeIfStatement (condition, current_block);
 188                 parent_if.false_statement = cif;
 189                 statement_stack.add (cif);
 190         }
 191
 192         public void open_while (CCodeExpression condition) {
 193                 statement_stack.add (current_block);
 194                 var parent_block = current_block;
 195
 196                 current_block = new CCodeBlock ();
 197
 198                 parent_block.add_statement (new CCodeWhileStatement (condition, current_block));
 199         }
 200
 201         public void open_for (CCodeExpression? initializer, CCodeExpression condition, CCodeExpression? iterator) {
 202                 statement_stack.add (current_block);
 203                 var parent_block = current_block;
 204
 205                 current_block = new CCodeBlock ();
 206
 207                 var cfor = new CCodeForStatement (condition, current_block);
 208                 if (initializer != null) {
 209                         cfor.add_initializer (initializer);
 210                 }
 211                 if (iterator != null) {
 212                         cfor.add_iterator (iterator);
 213                 }
 214
 215                 parent_block.add_statement (cfor);
 216         }
 217
 218         public void open_switch (CCodeExpression expression) {
 219                 statement_stack.add (current_block);
 220                 var parent_block = current_block;
 221
 222                 var cswitch = new CCodeSwitchStatement (expression);
 223                 current_block = cswitch;
 224
 225                 parent_block.add_statement (cswitch);
 226         }
 227
 228         public void add_label (string label) {
 229                 current_block.add_statement (new CCodeLabel (label));
 230         }
 231
 232         public void add_case (CCodeExpression expression) {
 233                 current_block.add_statement (new CCodeCaseStatement (expression));
 234         }
 235
 236         public void add_default () {
 237                 current_block.add_statement (new CCodeLabel ("default"));
 238         }
 239
 240         public void add_goto (string target) {
 241                 current_block.add_statement (new CCodeGotoStatement (target));
 242         }
 243
 244         public void add_expression (CCodeExpression expression) {
 245                 current_block.add_statement (new CCodeExpressionStatement (expression));
 246         }
 247
 248         public void add_assignment (CCodeExpression left, CCodeExpression right) {
 249                 add_expression (new CCodeAssignment (left, right));
 250         }
 251
 252         public void add_return (CCodeExpression? expression = null) {
 253                 current_block.add_statement (new CCodeReturnStatement (expression));
 254         }
 255
 256         public void add_break () {
 257                 current_block.add_statement (new CCodeBreakStatement ());
 258         }
 259
 260         public void add_continue () {
 261                 current_block.add_statement (new CCodeContinueStatement ());
 262         }
 263
 264         public void add_declaration (string type_name, CCodeDeclarator declarator, CCodeModifiers modifiers = 0) {
 265                 var stmt = new CCodeDeclaration (type_name);
 266                 stmt.add_declarator (declarator);
 267                 stmt.modifiers = modifiers;
 268                 current_block.add_statement (stmt);
 269         }
 270
 271         public void close () {
 272                 do {
 273                         var top = statement_stack[statement_stack.size - 1];
 274                         statement_stack.remove_at (statement_stack.size - 1);
 275                         current_block = top as CCodeBlock;
 276                 } while (current_block == null);
 277         }
 278 }