added doxygen comments
[libfirm] / ir / tr / entity.c
index c20618b..51fd0e6 100644 (file)
@@ -9,13 +9,21 @@
  * Copyright:   (c) 1998-2003 Universität Karlsruhe
  * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
  */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
 
-#include "firm_common_t.h"
-
+#ifdef HAVE_STRING_H
+# include <string.h>
+#endif
+#ifdef HAVE_STDLIB_H
 # include <stdlib.h>
+#endif
 # include <stddef.h>
-# include <string.h>
 
+#include "firm_common_t.h"
+
+# include "xmalloc.h"
 # include "entity_t.h"
 # include "mangle.h"
 # include "typegmod.h"
@@ -45,8 +53,17 @@ new_rd_entity (dbg_info *db, type *owner, ident *name, type *type);
 void
 init_entity (void)
 {
-  assert(unknown_type && "Call init_type before init_entity!");
-  new_rd_entity(NULL, unknown_type, new_id_from_str(UNKNOWN_ENTITY_NAME), unknown_type);
+  symconst_symbol sym;
+
+  assert(firm_unknown_type && "Call init_type before init_entity!");
+  assert(!unknown_entity && "Call init_entity only once!");
+  unknown_entity = new_rd_entity(NULL, firm_unknown_type, new_id_from_str(UNKNOWN_ENTITY_NAME), firm_unknown_type);
+  set_entity_visibility(unknown_entity, visibility_external_allocated);
+  set_entity_ld_ident(unknown_entity, get_entity_ident(unknown_entity));
+
+  sym.entity_p = unknown_entity;
+  current_ir_graph = get_const_code_irg();
+  unknown_entity->value = new_SymConst(sym, symconst_addr_ent);
 }
 
 
@@ -73,6 +90,9 @@ static INLINE void insert_entity_in_owner (entity *ent) {
   }
 }
 
+/**
+ * creates a new entity
+ */
 static INLINE entity *
 new_rd_entity (dbg_info *db, type *owner, ident *name, type *type)
 {
@@ -81,8 +101,8 @@ new_rd_entity (dbg_info *db, type *owner, ident *name, type *type)
 
   assert(!id_contains_char(name, ' ') && "entity name should not contain spaces");
 
-  res = (entity *) xmalloc (sizeof (entity));
-  memset(res, 0, sizeof(res));
+  res = xmalloc(sizeof(*res));
+  memset(res, 0, sizeof(*res));
   res->kind = k_entity;
   res->owner = owner;
   res->name = name;
@@ -95,7 +115,7 @@ new_rd_entity (dbg_info *db, type *owner, ident *name, type *type)
 
   res->visibility = visibility_local;
   res->offset = -1;
-  if (is_method_type(type)) {
+  if (is_Method_type(type)) {
     symconst_symbol sym;
     sym.entity_p = res;
     res->variability = variability_constant;
@@ -113,7 +133,7 @@ new_rd_entity (dbg_info *db, type *owner, ident *name, type *type)
   res->volatility    = volatility_non_volatile;
   res->stickyness    = stickyness_unsticky;
   res->ld_name       = NULL;
-  if (is_class_type(owner)) {
+  if (is_Class_type(owner)) {
     res->overwrites    = NEW_ARR_F(entity *, 0);
     res->overwrittenby = NEW_ARR_F(entity *, 0);
   } else {
@@ -126,7 +146,6 @@ new_rd_entity (dbg_info *db, type *owner, ident *name, type *type)
 
 #ifdef DEBUG_libfirm
   res->nr = get_irp_new_node_nr();
-  res->c_name = (char *)get_id_str (name);
 #endif /* DEBUG_libfirm */
 
   res->visit = 0;
@@ -137,8 +156,10 @@ new_rd_entity (dbg_info *db, type *owner, ident *name, type *type)
 
 entity *
 new_d_entity (type *owner, ident *name, type *type, dbg_info *db) {
+  entity *res;
+
   assert_legal_owner_of_ent(owner);
-  entity *res = new_rd_entity(db, owner, name, type);
+  res = new_rd_entity(db, owner, name, type);
   /* Remember entity in it's owner. */
   insert_entity_in_owner (res);
 
@@ -177,49 +198,48 @@ static void free_entity_attrs(entity *ent) {
 
 entity *
 copy_entity_own (entity *old, type *new_owner) {
-  entity *new;
+  entity *newe;
   assert(old && old->kind == k_entity);
   assert_legal_owner_of_ent(new_owner);
 
   if (old->owner == new_owner) return old;
-  new = (entity *) xmalloc (sizeof (entity));
-  memcpy (new, old, sizeof (entity));
-  new->owner = new_owner;
-  if (is_class_type(new_owner)) {
-    new->overwrites    = NEW_ARR_F(entity *, 0);
-    new->overwrittenby = NEW_ARR_F(entity *, 0);
+  newe = xmalloc(sizeof(*newe));
+  memcpy (newe, old, sizeof(*newe));
+  newe->owner = new_owner;
+  if (is_Class_type(new_owner)) {
+    newe->overwrites    = NEW_ARR_F(entity *, 0);
+    newe->overwrittenby = NEW_ARR_F(entity *, 0);
   }
 #ifdef DEBUG_libfirm
-  new->nr = get_irp_new_node_nr();
+  newe->nr = get_irp_new_node_nr();
 #endif
 
-  insert_entity_in_owner (new);
+  insert_entity_in_owner (newe);
 
-  return new;
+  return newe;
 }
 
 entity *
 copy_entity_name (entity *old, ident *new_name) {
-  entity *new;
+  entity *newe;
   assert(old && old->kind == k_entity);
 
   if (old->name == new_name) return old;
-  new = (entity *) xmalloc (sizeof (entity));
-  memcpy (new, old, sizeof (entity));
-  new->name = new_name;
-  new->ld_name = NULL;
-  if (is_class_type(new->owner)) {
-    new->overwrites    = DUP_ARR_F(entity *, old->overwrites);
-    new->overwrittenby = DUP_ARR_F(entity *, old->overwrittenby);
+  newe = xmalloc(sizeof(*newe));
+  memcpy(newe, old, sizeof(*newe));
+  newe->name = new_name;
+  newe->ld_name = NULL;
+  if (is_Class_type(newe->owner)) {
+    newe->overwrites    = DUP_ARR_F(entity *, old->overwrites);
+    newe->overwrittenby = DUP_ARR_F(entity *, old->overwrittenby);
   }
 #ifdef DEBUG_libfirm
-  new->nr = get_irp_new_node_nr();
-  new->c_name = (char *)get_id_str (new->name);
+  newe->nr = get_irp_new_node_nr();
 #endif
 
-  insert_entity_in_owner (new);
+  insert_entity_in_owner (newe);
 
-  return new;
+  return newe;
 }
 
 
@@ -367,7 +387,7 @@ set_entity_variability (entity *ent, ent_variability var)
 {
   assert(ent && ent->kind == k_entity);
   if (var == variability_part_constant)
-    assert(is_class_type(ent->type) || is_struct_type(ent->type));
+    assert(is_Class_type(ent->type) || is_Struct_type(ent->type));
 
   if ((is_compound_type(ent->type)) &&
       (ent->variability == variability_uninitialized) && (var != variability_uninitialized)) {
@@ -473,7 +493,7 @@ get_atomic_ent_value(entity *ent)
 void
 set_atomic_ent_value(entity *ent, ir_node *val) {
   assert(is_atomic_entity(ent) && (ent->variability != variability_uninitialized));
-  if (is_method_type(ent->type) && (ent->peculiarity == peculiarity_existent))
+  if (is_Method_type(ent->type) && (ent->peculiarity == peculiarity_existent))
     return;
   ent->value = val;
 }
@@ -483,7 +503,7 @@ set_atomic_ent_value(entity *ent, ir_node *val) {
 int is_irn_const_expression(ir_node *n) {
   ir_mode *m;
 
-  /* we are in dange iff an exception will arise. TODO: be more precisely,
+  /* we are in danger iff an exception will arise. TODO: be more precisely,
    * for instance Div. will NOT rise if divisor != 0
    */
   if (is_binop(n) && !is_fragile_op(n))
@@ -560,14 +580,17 @@ ir_node *copy_const_value(ir_node *n) {
 compound_graph_path *
 new_compound_graph_path(type *tp, int length) {
   compound_graph_path *res;
+
   assert(is_type(tp) && is_compound_type(tp));
   assert(length > 0);
 
-  res = (compound_graph_path *) calloc (1, sizeof(compound_graph_path) + (length-1) * sizeof(entity *));
-  res->kind          = k_ir_compound_graph_path;
-  res->tp            = tp;
-  res->len           = length;
-  res ->arr_indicees = (int *) calloc(length, sizeof(int));
+  res = xmalloc(sizeof(*res) + (length-1) * sizeof(res->nodes[0]));
+  memset(res, 0, sizeof(*res) + (length-1) * sizeof(res->nodes[0]));
+  res->kind         = k_ir_compound_graph_path;
+  res->tp           = tp;
+  res->len          = length;
+  res->arr_indicees = xcalloc(length, sizeof(res ->arr_indicees[0]));
+
   return res;
 }
 
@@ -592,6 +615,9 @@ int is_proper_compound_graph_path(compound_graph_path *gr, int pos) {
   type *owner = gr->tp;
   for (i = 0; i <= pos; i++) {
     node = get_compound_graph_path_node(gr, i);
+    if (node == NULL)
+      /* Path not yet complete. */
+      return true;
     if (get_entity_owner(node) != owner) return false;
     owner = get_entity_type(node);
   }
@@ -678,8 +704,8 @@ remove_compound_ent_value(entity *ent, entity *value_ent) {
     compound_graph_path *path = ent->val_paths[i];
     if (path->nodes[path->len-1] == value_ent) {
       for(; i < (ARR_LEN (ent->val_paths))-1; i++) {
-    ent->val_paths[i] = ent->val_paths[i+1];
-    ent->values[i]   = ent->values[i+1];
+        ent->val_paths[i] = ent->val_paths[i+1];
+        ent->values[i]   = ent->values[i+1];
       }
       ARR_SETLEN(entity*,  ent->val_paths, ARR_LEN(ent->val_paths) - 1);
       ARR_SETLEN(ir_node*, ent->values,    ARR_LEN(ent->values)    - 1);
@@ -695,7 +721,7 @@ add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
   path = new_compound_graph_path(owner_tp, 1);
   path->nodes[0] = member;
-  if (is_array_type(owner_tp)) {
+  if (is_Array_type(owner_tp)) {
     int max;
     int i;
 
@@ -760,9 +786,9 @@ set_array_entity_values(entity *ent, tarval **values, int num_vals) {
   ir_node *val;
   type *elttp = get_array_element_type(arrtp);
 
-  assert(is_array_type(arrtp));
+  assert(is_Array_type(arrtp));
   assert(get_array_n_dimensions(arrtp) == 1);
-  /* One bound is sufficient, the nunmber of constant fields makes the
+  /* One bound is sufficient, the number of constant fields makes the
      size. */
   assert(get_array_lower_bound (arrtp, 0) || get_array_upper_bound (arrtp, 0));
   assert(get_entity_variability(ent) != variability_uninitialized);
@@ -777,17 +803,20 @@ set_array_entity_values(entity *ent, tarval **values, int num_vals) {
 }
 
 int  get_compound_ent_value_offset_bits(entity *ent, int pos) {
+  compound_graph_path *path;
+  int i, path_len;
+  int offset = 0;
+
   assert(get_type_state(get_entity_type(ent)) == layout_fixed);
 
-  compound_graph_path *path = get_compound_ent_value_path(ent, pos);
-  int i, path_len = get_compound_graph_path_length(path);
-  int offset = 0;
+  path = get_compound_ent_value_path(ent, pos);
+  path_len = get_compound_graph_path_length(path);
 
   for (i = 0; i < path_len; ++i) {
     entity *node = get_compound_graph_path_node(path, i);
     type *node_tp = get_entity_type(node);
     type *owner_tp = get_entity_owner(node);
-    if (is_array_type(owner_tp)) {
+    if (is_Array_type(owner_tp)) {
       int size  = get_type_size_bits(node_tp);
       int align = get_type_alignment_bits(node_tp);
       if (size < align)
@@ -851,7 +880,7 @@ static int get_next_index(entity *elem_ent) {
   return next;
 }
 
-/* Compute the array indicees in compound graph paths of initialized entities.
+/* Compute the array indices in compound graph paths of initialized entities.
  *
  *  All arrays must have fixed lower and upper bounds.  One array can
  *  have an open bound.  If there are several open bounds, we do
@@ -860,7 +889,7 @@ static int get_next_index(entity *elem_ent) {
  *  array bounds must be representable as ints.
  *
  *  (If the bounds are not representable as ints we have to represent
- *  the indicees as firm nodes.  But the still we must be able to
+ *  the indices as firm nodes.  But the still we must be able to
  *  evaluate the index against the upper bound.)
  */
 void compute_compound_ent_array_indicees(entity *ent) {
@@ -874,12 +903,13 @@ void compute_compound_ent_array_indicees(entity *ent) {
   n_vals = get_compound_ent_n_values(ent);
   if (n_vals == 0) return;
 
-  /* We can not compute the indicees if there is more than one array
+  /* We can not compute the indexes if there is more than one array
      with an unknown bound.  For this remember the first entity that
      represents such an array. It could be ent. */
-  if (is_array_type(tp)) {
-    assert(get_array_n_dimensions(tp) == 1 && "other not implemented");
+  if (is_Array_type(tp)) {
     int dim = 0;
+
+    assert(get_array_n_dimensions(tp) == 1 && "other not implemented");
     if (!has_array_lower_bound(tp, dim) || !has_array_upper_bound(tp, dim))
      unknown_bound_entity = ent;
   }
@@ -893,38 +923,40 @@ void compute_compound_ent_array_indicees(entity *ent) {
       entity *node = get_compound_graph_path_node(path, j);
       type *elem_tp = get_entity_type(node);
 
-      if (is_array_type(elem_tp)) {
-    assert(get_array_n_dimensions(elem_tp) == 1 && "other not implemented");
-    int dim = 0;
-    if (!has_array_lower_bound(elem_tp, dim) || !has_array_upper_bound(elem_tp, dim)) {
-      if (!unknown_bound_entity) unknown_bound_entity = node;
-      if (node != unknown_bound_entity) return;
-    }
+      if (is_Array_type(elem_tp)) {
+        int dim = 0;
+        assert(get_array_n_dimensions(elem_tp) == 1 && "other not implemented");
+        if (!has_array_lower_bound(elem_tp, dim) || !has_array_upper_bound(elem_tp, dim)) {
+          if (!unknown_bound_entity) unknown_bound_entity = node;
+          if (node != unknown_bound_entity) return;
+        }
 
-    init_index(elem_tp);
+        init_index(elem_tp);
       }
     }
   }
 
-  /* Finally compute the indicees ... */
+  /* Finally compute the indexes ... */
   for (i = 0; i < n_vals; ++i) {
     compound_graph_path *path = get_compound_ent_value_path(ent, i);
     int j, path_len =  get_compound_graph_path_length(path);
     for (j = 0; j < path_len; ++j) {
       entity *node = get_compound_graph_path_node(path, j);
       type *owner_tp = get_entity_owner(node);
-      if (is_array_type(owner_tp))
-    set_compound_graph_path_array_index (path, j, get_next_index(node));
+      if (is_Array_type(owner_tp))
+        set_compound_graph_path_array_index (path, j, get_next_index(node));
     }
   }
 
 }
 
-
-static int *resize (int *buf, int new_size) {
-  int *new_buf = (int *)calloc(new_size, 4);
-  memcpy(new_buf, buf, new_size>1);
+/** resize: double the allocated buffer */
+static int *resize (int *buf, int *size) {
+  int new_size =  *size * 2;
+  int *new_buf = xcalloc(new_size, sizeof(new_buf[0]));
+  memcpy(new_buf, buf, *size);
   free(buf);
+  *size = new_size;
   return new_buf;
 }
 
@@ -938,14 +970,22 @@ static int *resize (int *buf, int new_size) {
    A second iteration now permutes the actual elements into two
    new arrays. */
 void sort_compound_ent_values(entity *ent) {
-  assert(get_type_state(get_entity_type(ent)) == layout_fixed);
-
-  type *tp = get_entity_type(ent);
-  int i, n_vals = get_compound_ent_n_values(ent);
-  int tp_size = get_type_size_bits(tp);
+  type *tp;
+  int i, n_vals;
+  int tp_size;
   int size;
   int *permutation;
 
+  int next;
+  ir_node **my_values;
+  compound_graph_path **my_paths;
+
+  assert(get_type_state(get_entity_type(ent)) == layout_fixed);
+
+  tp      = get_entity_type(ent);
+  n_vals  = get_compound_ent_n_values(ent);
+  tp_size = get_type_size_bits(tp);
+
   if (!is_compound_type(tp)                           ||
       (ent->variability == variability_uninitialized) ||
       (get_type_state(tp) != layout_fixed)            ||
@@ -953,12 +993,12 @@ void sort_compound_ent_values(entity *ent) {
 
   /* estimated upper bound for size. Better: use flexible array ... */
   size = ((tp_size > (n_vals * 32)) ? tp_size : (n_vals * 32)) * 4;
-  permutation = (int *)calloc(size, 4);
+  permutation = xcalloc(size, sizeof(permutation[0]));
+
   for (i = 0; i < n_vals; ++i) {
     int pos = get_compound_ent_value_offset_bits(ent, i);
     while (pos >= size) {
-      size = size + size;
-      permutation = resize(permutation, size);
+      permutation = resize(permutation, &size);
     }
     assert(pos < size);
     assert(permutation[pos] == 0 && "two values with the same offset");
@@ -967,9 +1007,9 @@ void sort_compound_ent_values(entity *ent) {
     //fprintf(stderr, "i: %d, pos: %d \n", i, pos);
   }
 
-  int next = 0;
-  ir_node **my_values = NEW_ARR_F(ir_node *, n_vals);
-  compound_graph_path **my_paths  = NEW_ARR_F(compound_graph_path *, n_vals);
+  next = 0;
+  my_values = NEW_ARR_F(ir_node *, n_vals);
+  my_paths  = NEW_ARR_F(compound_graph_path *, n_vals);
   for (i = 0; i < size; ++i) {
     int pos = permutation[i];
     if (pos) {
@@ -1011,21 +1051,21 @@ void
 
 void
 add_entity_overwrites(entity *ent, entity *overwritten) {
-  assert(ent && is_class_type(get_entity_owner(ent)));
+  assert(ent && is_Class_type(get_entity_owner(ent)));
   ARR_APP1(entity *, ent->overwrites, overwritten);
   ARR_APP1(entity *, overwritten->overwrittenby, ent);
 }
 
 int
 get_entity_n_overwrites(entity *ent) {
-  assert(ent && is_class_type(get_entity_owner(ent)));
+  assert(ent && is_Class_type(get_entity_owner(ent)));
   return (ARR_LEN(ent->overwrites));
 }
 
 int
 get_entity_overwrites_index(entity *ent, entity *overwritten) {
   int i;
-  assert(ent && is_class_type(get_entity_owner(ent)));
+  assert(ent && is_Class_type(get_entity_owner(ent)));
   for (i = 0; i < get_entity_n_overwrites(ent); i++)
     if (get_entity_overwrites(ent, i) == overwritten)
       return i;
@@ -1034,14 +1074,14 @@ get_entity_overwrites_index(entity *ent, entity *overwritten) {
 
 entity *
 get_entity_overwrites   (entity *ent, int pos) {
-  assert(ent && is_class_type(get_entity_owner(ent)));
+  assert(ent && is_Class_type(get_entity_owner(ent)));
   assert(pos < get_entity_n_overwrites(ent));
   return ent->overwrites[pos];
 }
 
 void
 set_entity_overwrites   (entity *ent, int pos, entity *overwritten) {
-  assert(ent && is_class_type(get_entity_owner(ent)));
+  assert(ent && is_Class_type(get_entity_owner(ent)));
   assert(pos < get_entity_n_overwrites(ent));
   ent->overwrites[pos] = overwritten;
 }
@@ -1049,7 +1089,7 @@ set_entity_overwrites   (entity *ent, int pos, entity *overwritten) {
 void
 remove_entity_overwrites(entity *ent, entity *overwritten) {
   int i;
-  assert(ent && is_class_type(get_entity_owner(ent)));
+  assert(ent && is_Class_type(get_entity_owner(ent)));
   for (i = 0; i < (ARR_LEN (ent->overwrites)); i++)
     if (ent->overwrites[i] == overwritten) {
       for(; i < (ARR_LEN (ent->overwrites))-1; i++)
@@ -1061,20 +1101,20 @@ remove_entity_overwrites(entity *ent, entity *overwritten) {
 
 void
 add_entity_overwrittenby   (entity *ent, entity *overwrites) {
-  assert(ent && is_class_type(get_entity_owner(ent)));
+  assert(ent && is_Class_type(get_entity_owner(ent)));
   add_entity_overwrites(overwrites, ent);
 }
 
 int
 get_entity_n_overwrittenby (entity *ent) {
-  assert(ent && is_class_type(get_entity_owner(ent)));
+  assert(ent && is_Class_type(get_entity_owner(ent)));
   return (ARR_LEN (ent->overwrittenby));
 }
 
 int
 get_entity_overwrittenby_index(entity *ent, entity *overwrites) {
   int i;
-  assert(ent && is_class_type(get_entity_owner(ent)));
+  assert(ent && is_Class_type(get_entity_owner(ent)));
   for (i = 0; i < get_entity_n_overwrittenby(ent); i++)
     if (get_entity_overwrittenby(ent, i) == overwrites)
       return i;
@@ -1083,21 +1123,21 @@ get_entity_overwrittenby_index(entity *ent, entity *overwrites) {
 
 entity *
 get_entity_overwrittenby   (entity *ent, int pos) {
-  assert(ent && is_class_type(get_entity_owner(ent)));
+  assert(ent && is_Class_type(get_entity_owner(ent)));
   assert(pos < get_entity_n_overwrittenby(ent));
   return ent->overwrittenby[pos];
 }
 
 void
 set_entity_overwrittenby   (entity *ent, int pos, entity *overwrites) {
-  assert(ent && is_class_type(get_entity_owner(ent)));
+  assert(ent && is_Class_type(get_entity_owner(ent)));
   assert(pos < get_entity_n_overwrittenby(ent));
   ent->overwrittenby[pos] = overwrites;
 }
 
 void    remove_entity_overwrittenby(entity *ent, entity *overwrites) {
   int i;
-  assert(ent  && is_class_type(get_entity_owner(ent)));
+  assert(ent  && is_Class_type(get_entity_owner(ent)));
   for (i = 0; i < (ARR_LEN (ent->overwrittenby)); i++)
     if (ent->overwrittenby[i] == overwrites) {
       for(; i < (ARR_LEN (ent->overwrittenby))-1; i++)
@@ -1125,12 +1165,15 @@ ir_graph *
 
 void
 set_entity_irg(entity *ent, ir_graph *irg) {
-  assert(ent && is_method_type(get_entity_type(ent)));
+  assert(ent && is_Method_type(get_entity_type(ent)));
   /* Wie kann man die Referenz auf einen IRG löschen, z.B. wenn die
    * Methode selbst nicht mehr aufgerufen werden kann, die Entität
-   * aber erhalten bleiben soll. */
+   * aber erhalten bleiben soll?  Wandle die Entitaet in description oder
+   * inherited um! */
   /* assert(irg); */
   assert((irg  && ent->peculiarity == peculiarity_existent) ||
+        (!irg && (ent->peculiarity == peculiarity_existent)
+         && (ent -> visibility == visibility_external_allocated)) ||
          (!irg && ent->peculiarity == peculiarity_description) ||
          (!irg && ent->peculiarity == peculiarity_inherited));
   ent->irg = irg;
@@ -1144,19 +1187,19 @@ int
 int is_atomic_entity(entity *ent) {
   type* t = get_entity_type(ent);
   assert(ent && ent->kind == k_entity);
-  return (is_primitive_type(t) || is_pointer_type(t) ||
-      is_enumeration_type(t) || is_method_type(t));
+  return (is_Primitive_type(t) || is_Pointer_type(t) ||
+      is_Enumeration_type(t) || is_Method_type(t));
 }
 
 int is_compound_entity(entity *ent) {
   type* t = get_entity_type(ent);
   assert(ent && ent->kind == k_entity);
-  return (is_class_type(t) || is_struct_type(t) ||
-      is_array_type(t) || is_union_type(t));
+  return (is_Class_type(t) || is_Struct_type(t) ||
+      is_Array_type(t) || is_Union_type(t));
 }
 
 /**
- * @todo not implemnted!!! */
+ * @todo not implemented!!! */
 bool equal_entity(entity *ent1, entity *ent2) {
   fprintf(stderr, " calling unimplemented equal entity!!! \n");
   return true;
@@ -1189,7 +1232,7 @@ bool entity_not_visited(entity *ent) {
 }
 
 /* Need two routines because I want to assert the result. */
-static entity *resolve_ent_polymorphy2 (type *dynamic_class, entitystatic_ent) {
+static entity *resolve_ent_polymorphy2 (type *dynamic_class, entity *static_ent) {
   int i, n_overwrittenby;
   entity *res = NULL;
 
@@ -1198,7 +1241,8 @@ static entity *resolve_ent_polymorphy2 (type *dynamic_class, entity* static_ent)
   n_overwrittenby = get_entity_n_overwrittenby(static_ent);
   for (i = 0; i < n_overwrittenby; ++i) {
     res = resolve_ent_polymorphy2(dynamic_class, get_entity_overwrittenby(static_ent, i));
-    if (res) break;
+    if (res)
+      break;
   }
 
   return res;
@@ -1209,7 +1253,7 @@ static entity *resolve_ent_polymorphy2 (type *dynamic_class, entity* static_ent)
  * Returns the dynamically referenced entity if the static entity and the
  * dynamic type are given.
  * Search downwards in overwritten tree. */
-entity *resolve_ent_polymorphy(type *dynamic_class, entitystatic_ent) {
+entity *resolve_ent_polymorphy(type *dynamic_class, entity *static_ent) {
   entity *res;
   assert(static_ent && static_ent->kind == k_entity);