Fix for Bug #1250685 (Unnecessary gender-specific terms in code).

Fixed bugs:
  - https://launchpad.net/bugs/1250685

(bzr r12997)

6 files changed, 365 insertions, 365 deletions

diff --git a/src/livarot/AVL.cpp b/src/livarot/AVL.cpp
index e8ece7f8c..17af5ee66 100644
--- a/src/livarot/AVL.cpp
+++ b/src/livarot/AVL.cpp
@@ -28,10 +28,10 @@ void AVLTree::MakeNew()
     for (int i = 0; i < 2; i++)
     {
         elem[i] = NULL;
-        son[i] = NULL;
+        child[i] = NULL;
     }
 
-    dad = NULL;
+    parent = NULL;
     balance = 0;
 }
 
@@ -47,32 +47,32 @@ void AVLTree::MakeDelete()
 
 AVLTree *AVLTree::Leftmost()
 {
-    return leafFromDad(NULL, LEFT);
+    return leafFromParent(NULL, LEFT);
 }
 
 AVLTree *AVLTree::leaf(AVLTree *from, Side s)
 {
-    if (from == son[1 - s]) {
-	if (son[s]) {
-	    return son[s]->leafFromDad(this, s);
+    if (from == child[1 - s]) {
+	if (child[s]) {
+	    return child[s]->leafFromParent(this, s);
 	}
-	else if (dad) {
-	    return dad->leaf(this, s);
+	else if (parent) {
+	    return parent->leaf(this, s);
 	}
     }
-    else if (from == son[s]) {
-	if (dad) {
-	    return dad->leaf(this, s);
+    else if (from == child[s]) {
+	if (parent) {
+	    return parent->leaf(this, s);
 	}
     }
 
     return NULL;
 }
 
-AVLTree *AVLTree::leafFromDad(AVLTree */*from*/, Side s)
+AVLTree *AVLTree::leafFromParent(AVLTree */*from*/, Side s)
 {
-    if (son[s]) {
-	return son[s]->leafFromDad(this, s);
+    if (child[s]) {
+	return child[s]->leafFromParent(this, s);
     }
 
     return this;
@@ -83,60 +83,60 @@ AVLTree::RestoreBalances (AVLTree * from, AVLTree * &racine)
 {
   if (from == NULL)
     {
-      if (dad)
-	return dad->RestoreBalances (this, racine);
+      if (parent)
+	return parent->RestoreBalances (this, racine);
     }
   else
     {
       if (balance == 0)
 	{
-	  if (from == son[LEFT])
+	  if (from == child[LEFT])
 	    balance = 1;
-	  if (from == son[RIGHT])
+	  if (from == child[RIGHT])
 	    balance = -1;
-	  if (dad)
-	    return dad->RestoreBalances (this, racine);
+	  if (parent)
+	    return parent->RestoreBalances (this, racine);
 	  return avl_no_err;
 	}
       else if (balance > 0)
 	{
-	  if (from == son[RIGHT])
+	  if (from == child[RIGHT])
 	    {
 	      balance = 0;
 	      return avl_no_err;
 	    }
-	  if (son[LEFT] == NULL)
+	  if (child[LEFT] == NULL)
 	    {
 //                              cout << "mierda\n";
 	      return avl_bal_err;
 	    }
 	  AVLTree *a = this;
-	  AVLTree *b = son[LEFT];
-	  AVLTree *e = son[RIGHT];
-	  AVLTree *c = son[LEFT]->son[LEFT];
-	  AVLTree *d = son[LEFT]->son[RIGHT];
-	  if (son[LEFT]->balance > 0)
+	  AVLTree *b = child[LEFT];
+	  AVLTree *e = child[RIGHT];
+	  AVLTree *c = child[LEFT]->child[LEFT];
+	  AVLTree *d = child[LEFT]->child[RIGHT];
+	  if (child[LEFT]->balance > 0)
 	    {
-	      AVLTree *r = dad;
+	      AVLTree *r = parent;
 
-	      a->dad = b;
-	      b->son[RIGHT] = a;
-	      a->son[RIGHT] = e;
+	      a->parent = b;
+	      b->child[RIGHT] = a;
+	      a->child[RIGHT] = e;
 	      if (e)
-		e->dad = a;
-	      a->son[LEFT] = d;
+		e->parent = a;
+	      a->child[LEFT] = d;
 	      if (d)
-		d->dad = a;
-	      b->son[LEFT] = c;
+		d->parent = a;
+	      b->child[LEFT] = c;
 	      if (c)
-		c->dad = b;
-	      b->dad = r;
+		c->parent = b;
+	      b->parent = r;
 	      if (r)
 		{
-		  if (r->son[LEFT] == a)
-		    r->son[LEFT] = b;
-		  if (r->son[RIGHT] == a)
-		    r->son[RIGHT] = b;
+		  if (r->child[LEFT] == a)
+		    r->child[LEFT] = b;
+		  if (r->child[RIGHT] == a)
+		    r->child[RIGHT] = b;
 		}
 	      if (racine == a)
 		racine = b;
@@ -147,39 +147,39 @@ AVLTree::RestoreBalances (AVLTree * from, AVLTree * &racine)
 	    }
 	  else
 	    {
-	      if (son[LEFT]->son[RIGHT] == NULL)
+	      if (child[LEFT]->child[RIGHT] == NULL)
 		{
 		  //                              cout << "mierda\n";
 		  return avl_bal_err;
 		}
-	      AVLTree *f = son[LEFT]->son[RIGHT]->son[LEFT];
-	      AVLTree *g = son[LEFT]->son[RIGHT]->son[RIGHT];
-	      AVLTree *r = dad;
-
-	      a->dad = d;
-	      d->son[RIGHT] = a;
-	      b->dad = d;
-	      d->son[LEFT] = b;
-	      a->son[LEFT] = g;
+	      AVLTree *f = child[LEFT]->child[RIGHT]->child[LEFT];
+	      AVLTree *g = child[LEFT]->child[RIGHT]->child[RIGHT];
+	      AVLTree *r = parent;
+
+	      a->parent = d;
+	      d->child[RIGHT] = a;
+	      b->parent = d;
+	      d->child[LEFT] = b;
+	      a->child[LEFT] = g;
 	      if (g)
-		g->dad = a;
-	      a->son[RIGHT] = e;
+		g->parent = a;
+	      a->child[RIGHT] = e;
 	      if (e)
-		e->dad = a;
-	      b->son[LEFT] = c;
+		e->parent = a;
+	      b->child[LEFT] = c;
 	      if (c)
-		c->dad = b;
-	      b->son[RIGHT] = f;
+		c->parent = b;
+	      b->child[RIGHT] = f;
 	      if (f)
-		f->dad = b;
+		f->parent = b;
 
-	      d->dad = r;
+	      d->parent = r;
 	      if (r)
 		{
-		  if (r->son[LEFT] == a)
-		    r->son[LEFT] = d;
-		  if (r->son[RIGHT] == a)
-		    r->son[RIGHT] = d;
+		  if (r->child[LEFT] == a)
+		    r->child[LEFT] = d;
+		  if (r->child[RIGHT] == a)
+		    r->child[RIGHT] = d;
 		}
 	      if (racine == a)
 		racine = d;
@@ -206,43 +206,43 @@ AVLTree::RestoreBalances (AVLTree * from, AVLTree * &racine)
 	}
       else if (balance < 0)
 	{
-	  if (from == son[LEFT])
+	  if (from == child[LEFT])
 	    {
 	      balance = 0;
 	      return avl_no_err;
 	    }
-	  if (son[RIGHT] == NULL)
+	  if (child[RIGHT] == NULL)
 	    {
 //                              cout << "mierda\n";
 	      return avl_bal_err;
 	    }
 	  AVLTree *a = this;
-	  AVLTree *b = son[RIGHT];
-	  AVLTree *e = son[LEFT];
-	  AVLTree *c = son[RIGHT]->son[RIGHT];
-	  AVLTree *d = son[RIGHT]->son[LEFT];
-	  AVLTree *r = dad;
-	  if (son[RIGHT]->balance < 0)
+	  AVLTree *b = child[RIGHT];
+	  AVLTree *e = child[LEFT];
+	  AVLTree *c = child[RIGHT]->child[RIGHT];
+	  AVLTree *d = child[RIGHT]->child[LEFT];
+	  AVLTree *r = parent;
+	  if (child[RIGHT]->balance < 0)
 	    {
 
-	      a->dad = b;
-	      b->son[LEFT] = a;
-	      a->son[LEFT] = e;
+	      a->parent = b;
+	      b->child[LEFT] = a;
+	      a->child[LEFT] = e;
 	      if (e)
-		e->dad = a;
-	      a->son[RIGHT] = d;
+		e->parent = a;
+	      a->child[RIGHT] = d;
 	      if (d)
-		d->dad = a;
-	      b->son[RIGHT] = c;
+		d->parent = a;
+	      b->child[RIGHT] = c;
 	      if (c)
-		c->dad = b;
-	      b->dad = r;
+		c->parent = b;
+	      b->parent = r;
 	      if (r)
 		{
-		  if (r->son[LEFT] == a)
-		    r->son[LEFT] = b;
-		  if (r->son[RIGHT] == a)
-		    r->son[RIGHT] = b;
+		  if (r->child[LEFT] == a)
+		    r->child[LEFT] = b;
+		  if (r->child[RIGHT] == a)
+		    r->child[RIGHT] = b;
 		}
 	      if (racine == a)
 		racine = b;
@@ -252,38 +252,38 @@ AVLTree::RestoreBalances (AVLTree * from, AVLTree * &racine)
 	    }
 	  else
 	    {
-	      if (son[RIGHT]->son[LEFT] == NULL)
+	      if (child[RIGHT]->child[LEFT] == NULL)
 		{
 //                                      cout << "mierda\n";
 		  return avl_bal_err;
 		}
-	      AVLTree *f = son[RIGHT]->son[LEFT]->son[RIGHT];
-	      AVLTree *g = son[RIGHT]->son[LEFT]->son[LEFT];
-
-	      a->dad = d;
-	      d->son[LEFT] = a;
-	      b->dad = d;
-	      d->son[RIGHT] = b;
-	      a->son[RIGHT] = g;
+	      AVLTree *f = child[RIGHT]->child[LEFT]->child[RIGHT];
+	      AVLTree *g = child[RIGHT]->child[LEFT]->child[LEFT];
+
+	      a->parent = d;
+	      d->child[LEFT] = a;
+	      b->parent = d;
+	      d->child[RIGHT] = b;
+	      a->child[RIGHT] = g;
 	      if (g)
-		g->dad = a;
-	      a->son[LEFT] = e;
+		g->parent = a;
+	      a->child[LEFT] = e;
 	      if (e)
-		e->dad = a;
-	      b->son[RIGHT] = c;
+		e->parent = a;
+	      b->child[RIGHT] = c;
 	      if (c)
-		c->dad = b;
-	      b->son[LEFT] = f;
+		c->parent = b;
+	      b->child[LEFT] = f;
 	      if (f)
-		f->dad = b;
+		f->parent = b;
 
-	      d->dad = r;
+	      d->parent = r;
 	      if (r)
 		{
-		  if (r->son[LEFT] == a)
-		    r->son[LEFT] = d;
-		  if (r->son[RIGHT] == a)
-		    r->son[RIGHT] = d;
+		  if (r->child[LEFT] == a)
+		    r->child[LEFT] = d;
+		  if (r->child[RIGHT] == a)
+		    r->child[RIGHT] = d;
 		}
 	      if (racine == a)
 		racine = d;
@@ -319,12 +319,12 @@ AVLTree::RestoreBalances (int diff, AVLTree * &racine)
       if (diff < 0)
 	{
 	  balance = 0;
-	  if (dad)
+	  if (parent)
 	    {
-	      if (this == dad->son[RIGHT])
-		return dad->RestoreBalances (1, racine);
-	      if (this == dad->son[LEFT])
-		return dad->RestoreBalances (-1, racine);
+	      if (this == parent->child[RIGHT])
+		return parent->RestoreBalances (1, racine);
+	      if (this == parent->child[LEFT])
+		return parent->RestoreBalances (-1, racine);
 	    }
 	  return avl_no_err;
 	}
@@ -333,38 +333,38 @@ AVLTree::RestoreBalances (int diff, AVLTree * &racine)
 	}
       else if (diff > 0)
 	{
-	  if (son[LEFT] == NULL)
+	  if (child[LEFT] == NULL)
 	    {
 //                              cout << "un probleme\n";
 	      return avl_bal_err;
 	    }
-	  AVLTree *r = dad;
+	  AVLTree *r = parent;
 	  AVLTree *a = this;
-	  AVLTree *b = son[RIGHT];
-	  AVLTree *e = son[LEFT];
-	  AVLTree *f = e->son[RIGHT];
-	  AVLTree *g = e->son[LEFT];
+	  AVLTree *b = child[RIGHT];
+	  AVLTree *e = child[LEFT];
+	  AVLTree *f = e->child[RIGHT];
+	  AVLTree *g = e->child[LEFT];
 	  if (e->balance > 0)
 	    {
-	      e->son[RIGHT] = a;
-	      e->son[LEFT] = g;
-	      a->son[RIGHT] = b;
-	      a->son[LEFT] = f;
+	      e->child[RIGHT] = a;
+	      e->child[LEFT] = g;
+	      a->child[RIGHT] = b;
+	      a->child[LEFT] = f;
 	      if (a)
-		a->dad = e;
+		a->parent = e;
 	      if (g)
-		g->dad = e;
+		g->parent = e;
 	      if (b)
-		b->dad = a;
+		b->parent = a;
 	      if (f)
-		f->dad = a;
-	      e->dad = r;
+		f->parent = a;
+	      e->parent = r;
 	      if (r)
 		{
-		  if (r->son[LEFT] == a)
-		    r->son[LEFT] = e;
-		  if (r->son[RIGHT] == a)
-		    r->son[RIGHT] = e;
+		  if (r->child[LEFT] == a)
+		    r->child[LEFT] = e;
+		  if (r->child[RIGHT] == a)
+		    r->child[RIGHT] = e;
 		}
 	      if (racine == this)
 		racine = e;
@@ -372,34 +372,34 @@ AVLTree::RestoreBalances (int diff, AVLTree * &racine)
 	      a->balance = 0;
 	      if (r)
 		{
-		  if (e == r->son[RIGHT])
+		  if (e == r->child[RIGHT])
 		    return r->RestoreBalances (1, racine);
-		  if (e == r->son[LEFT])
+		  if (e == r->child[LEFT])
 		    return r->RestoreBalances (-1, racine);
 		}
 	      return avl_no_err;
 	    }
 	  else if (e->balance == 0)
 	    {
-	      e->son[RIGHT] = a;
-	      e->son[LEFT] = g;
-	      a->son[RIGHT] = b;
-	      a->son[LEFT] = f;
+	      e->child[RIGHT] = a;
+	      e->child[LEFT] = g;
+	      a->child[RIGHT] = b;
+	      a->child[LEFT] = f;
 	      if (a)
-		a->dad = e;
+		a->parent = e;
 	      if (g)
-		g->dad = e;
+		g->parent = e;
 	      if (b)
-		b->dad = a;
+		b->parent = a;
 	      if (f)
-		f->dad = a;
-	      e->dad = r;
+		f->parent = a;
+	      e->parent = r;
 	      if (r)
 		{
-		  if (r->son[LEFT] == a)
-		    r->son[LEFT] = e;
-		  if (r->son[RIGHT] == a)
-		    r->son[RIGHT] = e;
+		  if (r->child[LEFT] == a)
+		    r->child[LEFT] = e;
+		  if (r->child[RIGHT] == a)
+		    r->child[RIGHT] = e;
 		}
 	      if (racine == this)
 		racine = e;
@@ -409,39 +409,39 @@ AVLTree::RestoreBalances (int diff, AVLTree * &racine)
 	    }
 	  else if (e->balance < 0)
 	    {
-	      if (son[LEFT]->son[RIGHT] == NULL)
+	      if (child[LEFT]->child[RIGHT] == NULL)
 		{
 //                                      cout << "un probleme\n";
 		  return avl_bal_err;
 		}
-	      AVLTree *i = son[LEFT]->son[RIGHT]->son[RIGHT];
-	      AVLTree *j = son[LEFT]->son[RIGHT]->son[LEFT];
-
-	      f->son[RIGHT] = a;
-	      f->son[LEFT] = e;
-	      a->son[RIGHT] = b;
-	      a->son[LEFT] = i;
-	      e->son[RIGHT] = j;
-	      e->son[LEFT] = g;
+	      AVLTree *i = child[LEFT]->child[RIGHT]->child[RIGHT];
+	      AVLTree *j = child[LEFT]->child[RIGHT]->child[LEFT];
+
+	      f->child[RIGHT] = a;
+	      f->child[LEFT] = e;
+	      a->child[RIGHT] = b;
+	      a->child[LEFT] = i;
+	      e->child[RIGHT] = j;
+	      e->child[LEFT] = g;
 	      if (b)
-		b->dad = a;
+		b->parent = a;
 	      if (i)
-		i->dad = a;
+		i->parent = a;
 	      if (g)
-		g->dad = e;
+		g->parent = e;
 	      if (j)
-		j->dad = e;
+		j->parent = e;
 	      if (a)
-		a->dad = f;
+		a->parent = f;
 	      if (e)
-		e->dad = f;
-	      f->dad = r;
+		e->parent = f;
+	      f->parent = r;
 	      if (r)
 		{
-		  if (r->son[LEFT] == a)
-		    r->son[LEFT] = f;
-		  if (r->son[RIGHT] == a)
-		    r->son[RIGHT] = f;
+		  if (r->child[LEFT] == a)
+		    r->child[LEFT] = f;
+		  if (r->child[RIGHT] == a)
+		    r->child[RIGHT] = f;
 		}
 	      if (racine == this)
 		racine = f;
@@ -464,9 +464,9 @@ AVLTree::RestoreBalances (int diff, AVLTree * &racine)
 		}
 	      if (r)
 		{
-		  if (f == r->son[RIGHT])
+		  if (f == r->child[RIGHT])
 		    return r->RestoreBalances (1, racine);
-		  if (f == r->son[LEFT])
+		  if (f == r->child[LEFT])
 		    return r->RestoreBalances (-1, racine);
 		}
 	      return avl_no_err;
@@ -492,38 +492,38 @@ AVLTree::RestoreBalances (int diff, AVLTree * &racine)
     {
       if (diff < 0)
 	{
-	  if (son[RIGHT] == NULL)
+	  if (child[RIGHT] == NULL)
 	    {
 //                              cout << "un probleme\n";
 	      return avl_bal_err;
 	    }
-	  AVLTree *r = dad;
+	  AVLTree *r = parent;
 	  AVLTree *a = this;
-	  AVLTree *b = son[LEFT];
-	  AVLTree *e = son[RIGHT];
-	  AVLTree *f = e->son[LEFT];
-	  AVLTree *g = e->son[RIGHT];
+	  AVLTree *b = child[LEFT];
+	  AVLTree *e = child[RIGHT];
+	  AVLTree *f = e->child[LEFT];
+	  AVLTree *g = e->child[RIGHT];
 	  if (e->balance < 0)
 	    {
-	      e->son[LEFT] = a;
-	      e->son[RIGHT] = g;
-	      a->son[LEFT] = b;
-	      a->son[RIGHT] = f;
+	      e->child[LEFT] = a;
+	      e->child[RIGHT] = g;
+	      a->child[LEFT] = b;
+	      a->child[RIGHT] = f;
 	      if (a)
-		a->dad = e;
+		a->parent = e;
 	      if (g)
-		g->dad = e;
+		g->parent = e;
 	      if (b)
-		b->dad = a;
+		b->parent = a;
 	      if (f)
-		f->dad = a;
-	      e->dad = r;
+		f->parent = a;
+	      e->parent = r;
 	      if (r)
 		{
-		  if (r->son[LEFT] == a)
-		    r->son[LEFT] = e;
-		  if (r->son[RIGHT] == a)
-		    r->son[RIGHT] = e;
+		  if (r->child[LEFT] == a)
+		    r->child[LEFT] = e;
+		  if (r->child[RIGHT] == a)
+		    r->child[RIGHT] = e;
 		}
 	      if (racine == this)
 		racine = e;
@@ -531,34 +531,34 @@ AVLTree::RestoreBalances (int diff, AVLTree * &racine)
 	      a->balance = 0;
 	      if (r)
 		{
-		  if (e == r->son[RIGHT])
+		  if (e == r->child[RIGHT])
 		    return r->RestoreBalances (1, racine);
-		  if (e == r->son[LEFT])
+		  if (e == r->child[LEFT])
 		    return r->RestoreBalances (-1, racine);
 		}
 	      return avl_no_err;
 	    }
 	  else if (e->balance == 0)
 	    {
-	      e->son[LEFT] = a;
-	      e->son[RIGHT] = g;
-	      a->son[LEFT] = b;
-	      a->son[RIGHT] = f;
+	      e->child[LEFT] = a;
+	      e->child[RIGHT] = g;
+	      a->child[LEFT] = b;
+	      a->child[RIGHT] = f;
 	      if (a)
-		a->dad = e;
+		a->parent = e;
 	      if (g)
-		g->dad = e;
+		g->parent = e;
 	      if (b)
-		b->dad = a;
+		b->parent = a;
 	      if (f)
-		f->dad = a;
-	      e->dad = r;
+		f->parent = a;
+	      e->parent = r;
 	      if (r)
 		{
-		  if (r->son[LEFT] == a)
-		    r->son[LEFT] = e;
-		  if (r->son[RIGHT] == a)
-		    r->son[RIGHT] = e;
+		  if (r->child[LEFT] == a)
+		    r->child[LEFT] = e;
+		  if (r->child[RIGHT] == a)
+		    r->child[RIGHT] = e;
 		}
 	      if (racine == this)
 		racine = e;
@@ -568,39 +568,39 @@ AVLTree::RestoreBalances (int diff, AVLTree * &racine)
 	    }
 	  else if (e->balance > 0)
 	    {
-	      if (son[RIGHT]->son[LEFT] == NULL)
+	      if (child[RIGHT]->child[LEFT] == NULL)
 		{
 //                                      cout << "un probleme\n";
 		  return avl_bal_err;
 		}
-	      AVLTree *i = son[RIGHT]->son[LEFT]->son[LEFT];
-	      AVLTree *j = son[RIGHT]->son[LEFT]->son[RIGHT];
-
-	      f->son[LEFT] = a;
-	      f->son[RIGHT] = e;
-	      a->son[LEFT] = b;
-	      a->son[RIGHT] = i;
-	      e->son[LEFT] = j;
-	      e->son[RIGHT] = g;
+	      AVLTree *i = child[RIGHT]->child[LEFT]->child[LEFT];
+	      AVLTree *j = child[RIGHT]->child[LEFT]->child[RIGHT];
+
+	      f->child[LEFT] = a;
+	      f->child[RIGHT] = e;
+	      a->child[LEFT] = b;
+	      a->child[RIGHT] = i;
+	      e->child[LEFT] = j;
+	      e->child[RIGHT] = g;
 	      if (b)
-		b->dad = a;
+		b->parent = a;
 	      if (i)
-		i->dad = a;
+		i->parent = a;
 	      if (g)
-		g->dad = e;
+		g->parent = e;
 	      if (j)
-		j->dad = e;
+		j->parent = e;
 	      if (a)
-		a->dad = f;
+		a->parent = f;
 	      if (e)
-		e->dad = f;
-	      f->dad = r;
+		e->parent = f;
+	      f->parent = r;
 	      if (r)
 		{
-		  if (r->son[LEFT] == a)
-		    r->son[LEFT] = f;
-		  if (r->son[RIGHT] == a)
-		    r->son[RIGHT] = f;
+		  if (r->child[LEFT] == a)
+		    r->child[LEFT] = f;
+		  if (r->child[RIGHT] == a)
+		    r->child[RIGHT] = f;
 		}
 	      if (racine == this)
 		racine = f;
@@ -623,9 +623,9 @@ AVLTree::RestoreBalances (int diff, AVLTree * &racine)
 		}
 	      if (r)
 		{
-		  if (f == r->son[RIGHT])
+		  if (f == r->child[RIGHT])
 		    return r->RestoreBalances (1, racine);
-		  if (f == r->son[LEFT])
+		  if (f == r->child[LEFT])
 		    return r->RestoreBalances (-1, racine);
 		}
 	      return avl_no_err;
@@ -637,12 +637,12 @@ AVLTree::RestoreBalances (int diff, AVLTree * &racine)
       else if (diff > 0)
 	{
 	  balance = 0;
-	  if (dad)
+	  if (parent)
 	    {
-	      if (this == dad->son[RIGHT])
-		return dad->RestoreBalances (1, racine);
-	      if (this == dad->son[LEFT])
-		return dad->RestoreBalances (-1, racine);
+	      if (this == parent->child[RIGHT])
+		return parent->RestoreBalances (1, racine);
+	      if (this == parent->child[LEFT])
+		return parent->RestoreBalances (-1, racine);
 	    }
 	  return avl_no_err;
 	}
@@ -673,126 +673,126 @@ AVLTree::Remove (AVLTree * &racine, AVLTree * &startNode, int &diff)
     elem[RIGHT]->elem[LEFT] = elem[LEFT];
   elem[LEFT] = elem[RIGHT] = NULL;
 
-  if (son[LEFT] && son[RIGHT])
+  if (child[LEFT] && child[RIGHT])
     {
-      AVLTree *newMe = son[LEFT]->leafFromDad(this, RIGHT);
-      if (newMe == NULL || newMe->son[RIGHT])
+      AVLTree *newMe = child[LEFT]->leafFromParent(this, RIGHT);
+      if (newMe == NULL || newMe->child[RIGHT])
 	{
 //                      cout << "pas normal\n";
 	  return avl_rm_err;
 	}
-      if (newMe == son[LEFT])
+      if (newMe == child[LEFT])
 	{
 	  startNode = newMe;
 	  diff = -1;
-	  newMe->son[RIGHT] = son[RIGHT];
-	  son[RIGHT]->dad = newMe;
-	  newMe->dad = dad;
-	  if (dad)
+	  newMe->child[RIGHT] = child[RIGHT];
+	  child[RIGHT]->parent = newMe;
+	  newMe->parent = parent;
+	  if (parent)
 	    {
-	      if (dad->son[LEFT] == this)
-		dad->son[LEFT] = newMe;
-	      if (dad->son[RIGHT] == this)
-		dad->son[RIGHT] = newMe;
+	      if (parent->child[LEFT] == this)
+		parent->child[LEFT] = newMe;
+	      if (parent->child[RIGHT] == this)
+		parent->child[RIGHT] = newMe;
 	    }
 	}
       else
 	{
-	  AVLTree *oDad = newMe->dad;
-	  startNode = oDad;
+	  AVLTree *oParent = newMe->parent;
+	  startNode = oParent;
 	  diff = 1;
 
-	  oDad->son[RIGHT] = newMe->son[LEFT];
-	  if (newMe->son[LEFT])
-	    newMe->son[LEFT]->dad = oDad;
+	  oParent->child[RIGHT] = newMe->child[LEFT];
+	  if (newMe->child[LEFT])
+	    newMe->child[LEFT]->parent = oParent;
 
-	  newMe->dad = dad;
-	  newMe->son[LEFT] = son[LEFT];
-	  newMe->son[RIGHT] = son[RIGHT];
-	  if (dad)
+	  newMe->parent = parent;
+	  newMe->child[LEFT] = child[LEFT];
+	  newMe->child[RIGHT] = child[RIGHT];
+	  if (parent)
 	    {
-	      if (dad->son[LEFT] == this)
-		dad->son[LEFT] = newMe;
-	      if (dad->son[RIGHT] == this)
-		dad->son[RIGHT] = newMe;
+	      if (parent->child[LEFT] == this)
+		parent->child[LEFT] = newMe;
+	      if (parent->child[RIGHT] == this)
+		parent->child[RIGHT] = newMe;
 	    }
-	  if (son[LEFT])
-	    son[LEFT]->dad = newMe;
-	  if (son[RIGHT])
-	    son[RIGHT]->dad = newMe;
+	  if (child[LEFT])
+	    child[LEFT]->parent = newMe;
+	  if (child[RIGHT])
+	    child[RIGHT]->parent = newMe;
 	}
       newMe->balance = balance;
       if (racine == this)
 	racine = newMe;
     }
-  else if (son[LEFT])
+  else if (child[LEFT])
     {
-      startNode = dad;
+      startNode = parent;
       diff = 0;
-      if (dad)
+      if (parent)
 	{
-	  if (this == dad->son[LEFT])
+	  if (this == parent->child[LEFT])
 	    diff = -1;
-	  if (this == dad->son[RIGHT])
+	  if (this == parent->child[RIGHT])
 	    diff = 1;
 	}
-      if (dad)
+      if (parent)
 	{
-	  if (dad->son[LEFT] == this)
-	    dad->son[LEFT] = son[LEFT];
-	  if (dad->son[RIGHT] == this)
-	    dad->son[RIGHT] = son[LEFT];
+	  if (parent->child[LEFT] == this)
+	    parent->child[LEFT] = child[LEFT];
+	  if (parent->child[RIGHT] == this)
+	    parent->child[RIGHT] = child[LEFT];
 	}
-      if (son[LEFT]->dad == this)
-	son[LEFT]->dad = dad;
+      if (child[LEFT]->parent == this)
+	child[LEFT]->parent = parent;
       if (racine == this)
-	racine = son[LEFT];
+	racine = child[LEFT];
     }
-  else if (son[RIGHT])
+  else if (child[RIGHT])
     {
-      startNode = dad;
+      startNode = parent;
       diff = 0;
-      if (dad)
+      if (parent)
 	{
-	  if (this == dad->son[LEFT])
+	  if (this == parent->child[LEFT])
 	    diff = -1;
-	  if (this == dad->son[RIGHT])
+	  if (this == parent->child[RIGHT])
 	    diff = 1;
 	}
-      if (dad)
+      if (parent)
 	{
-	  if (dad->son[LEFT] == this)
-	    dad->son[LEFT] = son[RIGHT];
-	  if (dad->son[RIGHT] == this)
-	    dad->son[RIGHT] = son[RIGHT];
+	  if (parent->child[LEFT] == this)
+	    parent->child[LEFT] = child[RIGHT];
+	  if (parent->child[RIGHT] == this)
+	    parent->child[RIGHT] = child[RIGHT];
 	}
-      if (son[RIGHT]->dad == this)
-	son[RIGHT]->dad = dad;
+      if (child[RIGHT]->parent == this)
+	child[RIGHT]->parent = parent;
       if (racine == this)
-	racine = son[RIGHT];
+	racine = child[RIGHT];
     }
   else
     {
-      startNode = dad;
+      startNode = parent;
       diff = 0;
-      if (dad)
+      if (parent)
 	{
-	  if (this == dad->son[LEFT])
+	  if (this == parent->child[LEFT])
 	    diff = -1;
-	  if (this == dad->son[RIGHT])
+	  if (this == parent->child[RIGHT])
 	    diff = 1;
 	}
-      if (dad)
+      if (parent)
 	{
-	  if (dad->son[LEFT] == this)
-	    dad->son[LEFT] = NULL;
-	  if (dad->son[RIGHT] == this)
-	    dad->son[RIGHT] = NULL;
+	  if (parent->child[LEFT] == this)
+	    parent->child[LEFT] = NULL;
+	  if (parent->child[RIGHT] == this)
+	    parent->child[RIGHT] = NULL;
 	}
       if (racine == this)
 	racine = NULL;
     }
-  dad = son[RIGHT] = son[LEFT] = NULL;
+  parent = child[RIGHT] = child[LEFT] = NULL;
   balance = 0;
   return avl_no_err;
 }
@@ -828,43 +828,43 @@ AVLTree::Insert (AVLTree * &racine, int insertType, AVLTree * insertL,
 	}
       else if (insertType == found_on_left)
 	{
-	  if (insertR == NULL || insertR->son[LEFT])
+	  if (insertR == NULL || insertR->child[LEFT])
 	    {
 //                              cout << "ngou?\n";
 	      return avl_ins_err;
 	    }
-	  insertR->son[LEFT] = this;
-	  dad = insertR;
+	  insertR->child[LEFT] = this;
+	  parent = insertR;
 	  insertOn(LEFT, insertR);
 	}
       else if (insertType == found_on_right)
 	{
-	  if (insertL == NULL || insertL->son[RIGHT])
+	  if (insertL == NULL || insertL->child[RIGHT])
 	    {
 //                              cout << "ngou?\n";
 	      return avl_ins_err;
 	    }
-	  insertL->son[RIGHT] = this;
-	  dad = insertL;
+	  insertL->child[RIGHT] = this;
+	  parent = insertL;
 	  insertOn(RIGHT, insertL);
 	}
       else if (insertType == found_between)
 	{
 	  if (insertR == NULL || insertL == NULL
-	      || (insertR->son[LEFT] != NULL && insertL->son[RIGHT] != NULL))
+	      || (insertR->child[LEFT] != NULL && insertL->child[RIGHT] != NULL))
 	    {
 //                              cout << "ngou?\n";
 	      return avl_ins_err;
 	    }
-	  if (insertR->son[LEFT] == NULL)
+	  if (insertR->child[LEFT] == NULL)
 	    {
-	      insertR->son[LEFT] = this;
-	      dad = insertR;
+	      insertR->child[LEFT] = this;
+	      parent = insertR;
 	    }
-	  else if (insertL->son[RIGHT] == NULL)
+	  else if (insertL->child[RIGHT] == NULL)
 	    {
-	      insertL->son[RIGHT] = this;
-	      dad = insertL;
+	      insertL->child[RIGHT] = this;
+	      parent = insertL;
 	    }
 	  insertBetween (insertL, insertR);
 	}
@@ -877,22 +877,22 @@ AVLTree::Insert (AVLTree * &racine, int insertType, AVLTree * insertL,
 	    }
 	  // et on insere
 
-	  if (insertL->son[RIGHT])
+	  if (insertL->child[RIGHT])
 	    {
-		insertL = insertL->son[RIGHT]->leafFromDad(insertL, LEFT);
-	      if (insertL->son[LEFT])
+		insertL = insertL->child[RIGHT]->leafFromParent(insertL, LEFT);
+	      if (insertL->child[LEFT])
 		{
 //                                      cout << "ngou?\n";
 		  return avl_ins_err;
 		}
-	      insertL->son[LEFT] = this;
-	      this->dad = insertL;
+	      insertL->child[LEFT] = this;
+	      this->parent = insertL;
 	      insertBetween (insertL->elem[LEFT], insertL);
 	    }
 	  else
 	    {
-	      insertL->son[RIGHT] = this;
-	      dad = insertL;
+	      insertL->child[RIGHT] = this;
+	      parent = insertL;
 	      insertBetween (insertL, insertL->elem[RIGHT]);
 	    }
 	}
@@ -915,24 +915,24 @@ AVLTree::Relocate (AVLTree * to)
   to->elem[LEFT] = elem[LEFT];
   to->elem[RIGHT] = elem[RIGHT];
     
-  if (dad)
+  if (parent)
     {
-      if (dad->son[LEFT] == this)
-	dad->son[LEFT] = to;
-      if (dad->son[RIGHT] == this)
-	dad->son[RIGHT] = to;
+      if (parent->child[LEFT] == this)
+	parent->child[LEFT] = to;
+      if (parent->child[RIGHT] == this)
+	parent->child[RIGHT] = to;
     }
-  if (son[RIGHT])
+  if (child[RIGHT])
     {
-      son[RIGHT]->dad = to;
+      child[RIGHT]->parent = to;
     }
-  if (son[LEFT])
+  if (child[LEFT])
     {
-      son[LEFT]->dad = to;
+      child[LEFT]->parent = to;
     }
-  to->dad = dad;
-  to->son[RIGHT] = son[RIGHT];
-  to->son[LEFT] = son[LEFT];
+  to->parent = parent;
+  to->child[RIGHT] = child[RIGHT];
+  to->child[LEFT] = child[LEFT];
 }
 
 
diff --git a/src/livarot/AVL.h b/src/livarot/AVL.h
index cc0f095cc..741abfaf2 100644
--- a/src/livarot/AVL.h
+++ b/src/livarot/AVL.h
@@ -30,7 +30,7 @@ public:
 
 protected:    
 
-    AVLTree *son[2];
+    AVLTree *child[2];
 
     AVLTree();
     virtual ~AVLTree();
@@ -57,7 +57,7 @@ protected:
 
 private:
 
-    AVLTree *dad;
+    AVLTree *parent;
 
     int balance;
 
@@ -78,7 +78,7 @@ private:
     void insertOn(Side s, AVLTree *of);
     void insertBetween(AVLTree *l, AVLTree *r);
     AVLTree *leaf(AVLTree *from, Side s);
-    AVLTree *leafFromDad(AVLTree *from, Side s);
+    AVLTree *leafFromParent(AVLTree *from, Side s);
 };
 
 #endif
diff --git a/src/livarot/PathCutting.cpp b/src/livarot/PathCutting.cpp
index 201f64b54..0dc7ede50 100644
--- a/src/livarot/PathCutting.cpp
+++ b/src/livarot/PathCutting.cpp
@@ -641,21 +641,21 @@ Path**      Path::SubPathsWithNesting(int &outNb,bool killNoSurf,int nbNest,int*
           }
           curAdd=NULL;
         }
-        Path*  hasDad=NULL;
+        Path*  hasParent=NULL;
         for (int j=0;j<nbNest;j++) {
           if ( conts[j] == i && nesting[j] >= 0 ) {
-            int  dadMvt=conts[nesting[j]];
+            int  parentMvt=conts[nesting[j]];
             for (int k=0;k<nbRes;k++) {
-              if ( res[k] && res[k]->descr_cmd.empty() == false && res[k]->descr_cmd[0]->associated == dadMvt ) {
-                hasDad=res[k];
+              if ( res[k] && res[k]->descr_cmd.empty() == false && res[k]->descr_cmd[0]->associated == parentMvt ) {
+                hasParent=res[k];
                 break;
               }
             }
           }
           if ( conts[j] > i  ) break;
         }
-        if ( hasDad ) {
-          curAdd=hasDad;
+        if ( hasParent ) {
+          curAdd=hasParent;
           increment=true;
         } else {
           curAdd=new Path;
diff --git a/src/livarot/ShapeMisc.cpp b/src/livarot/ShapeMisc.cpp
index e5a98f0cf..c0bfe9428 100644
--- a/src/livarot/ShapeMisc.cpp
+++ b/src/livarot/ShapeMisc.cpp
@@ -373,7 +373,7 @@ Shape::ConvertToFormeNested (Path * dest, int nbP, Path * *orig, int /*wildPath*
   int lastPtUsed = 0;
   do
   {
-    int dadContour=-1;
+    int parentContour=-1;
     int childEdge = -1;
     bool foundChild = false;
     int startBord = -1;
@@ -387,10 +387,10 @@ Shape::ConvertToFormeNested (Path * dest, int nbP, Path * *orig, int /*wildPath*
       {
         int askTo = pData[fi].askForWindingB;
         if (askTo < 0 || askTo >= numberOfEdges() ) {
-          dadContour=-1;
+          parentContour=-1;
         } else {
-          dadContour = GPOINTER_TO_INT(swdData[askTo].misc);
-          dadContour-=1; // pour compenser le decalage
+          parentContour = GPOINTER_TO_INT(swdData[askTo].misc);
+          parentContour-=1; // pour compenser le decalage
           childEdge = getPoint(fi).incidentEdge[FIRST];
         }
       }
@@ -463,7 +463,7 @@ Shape::ConvertToFormeNested (Path * dest, int nbP, Path * *orig, int /*wildPath*
               contStart=(int*)g_realloc(contStart,(nbNest+1)*sizeof(int));
               contStart[nbNest]=dest->descr_cmd.size();
               if (foundChild) {
-                nesting[nbNest++]=dadContour;
+                nesting[nbNest++]=parentContour;
                 foundChild = false;
               } else {
                 nesting[nbNest++]=-1; // contient des bouts de coupure -> a part
@@ -504,7 +504,7 @@ Shape::ConvertToFormeNested (Path * dest, int nbP, Path * *orig, int /*wildPath*
               contStart=(int*)g_realloc(contStart,(nbNest+1)*sizeof(int));
               contStart[nbNest]=dest->descr_cmd.size();
               if (foundChild) {
-                nesting[nbNest++]=dadContour;
+                nesting[nbNest++]=parentContour;
                 foundChild = false;
               } else {
                 nesting[nbNest++]=-1; // contient des bouts de coupure -> a part
diff --git a/src/livarot/sweep-event.cpp b/src/livarot/sweep-event.cpp
index 6f3a4d246..48354fc46 100644
--- a/src/livarot/sweep-event.cpp
+++ b/src/livarot/sweep-event.cpp
@@ -146,11 +146,11 @@ void SweepEventQueue::remove(SweepEvent *e)
     }
     
     while (2 * curInd + 1 < nbEvt) {
-	int const son1 = 2 * curInd + 1;
-	int const son2 = son1 + 1;
-	int const no1 = inds[son1];
-	int const no2 = inds[son2];
-	if (son2 < nbEvt) {
+	int const child1 = 2 * curInd + 1;
+	int const child2 = child1 + 1;
+	int const no1 = inds[child1];
+	int const no2 = inds[child2];
+	if (child2 < nbEvt) {
 	    if (px[1] > events[no1].posx[1]
 		|| (px[1] == events[no1].posx[1]
 		    && px[0] > events[no1].posx[0]))
@@ -159,28 +159,28 @@ void SweepEventQueue::remove(SweepEvent *e)
 		    || (events[no2].posx[1] == events[no1].posx[1]
 			&& events[no2].posx[0] > events[no1].posx[0]))
 		{
-		    events[to].ind = son1;
+		    events[to].ind = child1;
 		    events[no1].ind = curInd;
-		    inds[son1] = to;
+		    inds[child1] = to;
 		    inds[curInd] = no1;
-		    curInd = son1;
+		    curInd = child1;
 		} else {
-		    events[to].ind = son2;
+		    events[to].ind = child2;
 		    events[no2].ind = curInd;
-		    inds[son2] = to;
+		    inds[child2] = to;
 		    inds[curInd] = no2;
-		    curInd = son2;
+		    curInd = child2;
 		}
 	    } else {
 		if (px[1] > events[no2].posx[1]
 		    || (px[1] == events[no2].posx[1]
 			&& px[0] > events[no2].posx[0]))
 		{
-		    events[to].ind = son2;
+		    events[to].ind = child2;
 		    events[no2].ind = curInd;
-		    inds[son2] = to;
+		    inds[child2] = to;
 		    inds[curInd] = no2;
-		    curInd = son2;
+		    curInd = child2;
 		} else {
 		    break;
 		}
@@ -190,9 +190,9 @@ void SweepEventQueue::remove(SweepEvent *e)
 		|| (px[1] == events[no1].posx[1]
 		    && px[0] > events[no1].posx[0]))
 	    {
-		events[to].ind = son1;
+		events[to].ind = child1;
 		events[no1].ind = curInd;
-		inds[son1] = to;
+		inds[child1] = to;
 		inds[curInd] = no1;
 	    }
 	    
diff --git a/src/livarot/sweep-tree.cpp b/src/livarot/sweep-tree.cpp
index 0cfd6bc52..7a016a2ee 100644
--- a/src/livarot/sweep-tree.cpp
+++ b/src/livarot/sweep-tree.cpp
@@ -131,8 +131,8 @@ SweepTree::Find(Geom::Point const &px, SweepTree *newOne, SweepTree *&insertL,
         }
     }
     if (y < 0) {
-        if (son[LEFT]) {
-            return (static_cast<SweepTree *>(son[LEFT]))->Find(px, newOne,
+        if (child[LEFT]) {
+            return (static_cast<SweepTree *>(child[LEFT]))->Find(px, newOne,
                                                                insertL, insertR,
                                                                sweepSens);
 	} else {
@@ -145,8 +145,8 @@ SweepTree::Find(Geom::Point const &px, SweepTree *newOne, SweepTree *&insertL,
 	    }
 	}
     } else {
-        if (son[RIGHT]) {
-            return (static_cast<SweepTree *>(son[RIGHT]))->Find(px, newOne,
+        if (child[RIGHT]) {
+            return (static_cast<SweepTree *>(child[RIGHT]))->Find(px, newOne,
                                                                 insertL, insertR,
                                                                 sweepSens);
 	} else {
@@ -189,9 +189,9 @@ SweepTree::Find(Geom::Point const &px, SweepTree * &insertL,
     }
   if (y < 0)
     {
-      if (son[LEFT])
+      if (child[LEFT])
 	{
-	  return (static_cast<SweepTree *>(son[LEFT]))->Find(px, insertL,
+	  return (static_cast<SweepTree *>(child[LEFT]))->Find(px, insertL,
 							    insertR);
 	}
       else
@@ -210,9 +210,9 @@ SweepTree::Find(Geom::Point const &px, SweepTree * &insertL,
     }
   else
     {
-      if (son[RIGHT])
+      if (child[RIGHT])
 	{
-	  return (static_cast<SweepTree *>(son[RIGHT]))->Find(px, insertL,
+	  return (static_cast<SweepTree *>(child[RIGHT]))->Find(px, insertL,
 							    insertR);
 	}
       else