replaced variable args macros by functions to make it c89 compatible

[libfirm] / ir / ana / irouts.c

diff --git a/ir/ana/irouts.c b/ir/ana/irouts.c
index 3ae97c8..df5a333 100644 (file)
--- a/ir/ana/irouts.c
+++ b/ir/ana/irouts.c
@@ -1,11 +1,25 @@
-/* Copyright (C) 2002 by Universitaet Karlsruhe
-** All rights reserved.
-**
-** Authors:  Goetz Lindenmaier
-**
-** irouts.c --- Compute out edges for ir nodes (also called def-use
-** edges).
-**
+/*
+ * Project:     libFIRM
+ * File name:   ir/ana/irouts.c
+ * Purpose:     Compute and access out edges.
+ * Author:      Goetz Lindenmaier
+ * Modified by:
+ * Created:     1.2002
+ * CVS-ID:      $Id$
+ * Copyright:   (c) 2002-2003 Universität Karlsruhe
+ * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ */
+
+
+
+ /* Copyright (C) 2002 by Universitaet Karlsruhe
+* All rights reserved.
+*
+* Authors:  Goetz Lindenmaier
+*
+* irouts.c --- Compute out edges for ir nodes (also called def-use
+* edges).
+*
 */
 
 /* $Id$ */
@@ -20,25 +34,25 @@
 /**********************************************************************/
 
 /* returns the number of successors of the node: */
-inline int get_irn_n_outs    (ir_node *node) {
+INLINE int get_irn_n_outs    (ir_node *node) {
   return (int)(node->out[0]);
 }
 
 /* Access successor n */
-inline ir_node *get_irn_out      (ir_node *node, int pos) {
+INLINE ir_node *get_irn_out      (ir_node *node, int pos) {
   assert(node);
   assert(pos >= 0 && pos < get_irn_n_outs(node));
   return node->out[pos+1];
 }
 
-inline void set_irn_out      (ir_node *node, int pos, ir_node *out) {
+INLINE void set_irn_out      (ir_node *node, int pos, ir_node *out) {
   assert(node && out);
   assert(pos >= 0 && pos < get_irn_n_outs(node));
   node->out[pos+1] = out;
 }
 
 
-inline int get_Block_n_cfg_outs (ir_node *bl) {
+INLINE int get_Block_n_cfg_outs (ir_node *bl) {
   int i, n_cfg_outs = 0;
   assert(bl && (get_irn_op(bl) == op_Block));
   for (i = 0; i < (int)bl->out[0]; i++)
@@ -48,27 +62,27 @@ inline int get_Block_n_cfg_outs (ir_node *bl) {
 }
 
 
-inline ir_node *get_Block_cfg_out  (ir_node *bl, int pos) {
+INLINE ir_node *get_Block_cfg_out  (ir_node *bl, int pos) {
   int i, out_pos = 0;
   assert(bl && (get_irn_op(bl) == op_Block));
   for (i = 0; i < (int)bl->out[0]; i++)
-    if (get_irn_mode(bl->out[i+1]) == mode_X)
+    if ((get_irn_mode(bl->out[i+1]) == mode_X)  &&
+       (get_irn_op(bl->out[i+1]) != op_End)) {
       if (out_pos == pos) {
        ir_node *cfop = bl->out[i+1];
        return cfop->out[0+1];
       } else {
        out_pos++;
       }
+    }
   return NULL;
 }
 
-void irg_out_walk_2(ir_node *node,  void (pre)(ir_node*, void*),
-                   void (post)(ir_node*, void*), void *env) {
+void irg_out_walk_2(ir_node *node,  irg_walk_func *pre,
+                   irg_walk_func *post, void *env) {
   int i;
   ir_node *succ;
 
-  //printf("++ in walker (%d outs) ", get_irn_n_outs(node)); DDMSG2(node);
-
   assert(node);
   assert(get_irn_visited(node) < get_irg_visited(current_ir_graph));
 
@@ -84,13 +98,12 @@ void irg_out_walk_2(ir_node *node,  void (pre)(ir_node*, void*),
 
   if (post) post(node, env);
 
-  //printf("++ done walking "); DDMSG2(node);
   return;
 }
 
 void irg_out_walk(ir_node *node,
-                 void (pre)(ir_node*, void*), void (post)(ir_node*, void*),
-                 void *env) {
+                       irg_walk_func *pre, irg_walk_func *post,
+                       void *env) {
   assert(node);
   if (get_irg_outs_state(current_ir_graph) != no_outs) {
     inc_irg_visited (current_ir_graph);
@@ -100,9 +113,9 @@ void irg_out_walk(ir_node *node,
 }
 
 void irg_out_block_walk2(ir_node *bl,
-                       void (pre)(ir_node*, void*), void (post)(ir_node*, void*),
+                       irg_walk_func *pre, irg_walk_func *post,
                        void *env) {
-  int i, out_pos;
+  int i;
 
   assert(get_irn_opcode(bl) == iro_Block);
 
@@ -129,7 +142,7 @@ void irg_out_block_walk2(ir_node *bl,
 /* Walks only over Block nodes in the graph.  Has it's own visited
    flag, so that it can be interleaved with the other walker.         */
 void irg_out_block_walk(ir_node *node,
-                       void (pre)(ir_node*, void*), void (post)(ir_node*, void*),
+                       irg_walk_func *pre, irg_walk_func *post,
                        void *env) {
 
   assert((get_irn_op(node) == op_Block) || (get_irn_mode(node) == mode_X));
@@ -165,7 +178,7 @@ void irg_out_block_walk(ir_node *node,
 
 
 /* Returns the amount of out edges for not yet visited successors. */
-int count_outs(ir_node *n) {
+static int count_outs(ir_node *n) {
   int start, i, res;
   ir_node *succ;
 
@@ -187,7 +200,7 @@ int count_outs(ir_node *n) {
   return res;
 }
 
-ir_node **set_out_edges(ir_node *n, ir_node **free) {
+static ir_node **set_out_edges(ir_node *n, ir_node **free) {
   int n_outs, start, i;
   ir_node *succ;
 
@@ -215,8 +228,8 @@ ir_node **set_out_edges(ir_node *n, ir_node **free) {
   return free;
 }
 
-inline void fix_start_proj(ir_graph *irg) {
-  ir_node *proj, *startbl;
+static INLINE void fix_start_proj(ir_graph *irg) {
+  ir_node *proj = NULL, *startbl;
   int i;
   if (get_Block_n_cfg_outs(get_irg_start_block(irg))) {
     startbl = get_irg_start_block(irg);