From: Pascale Noyret <pascale.noyret@edf.fr>
Date: Mon, 3 Dec 2012 12:23:30 +0000 (+0000)
Subject: Noyau de la STA11 du 3/12
X-Git-Tag: V6_6_0rc1~3
X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=21703ecf309ed6bef7d3c11d9dd7bce85f15e481;p=tools%2Feficas.git

Noyau de la STA11 du 3/12
---

diff --git a/Accas/A_JDC.py b/Accas/A_JDC.py
index 1ac7c323..aa89eedb 100644
--- a/Accas/A_JDC.py
+++ b/Accas/A_JDC.py
@@ -30,3 +30,4 @@ class JDC(jdc.JDC,I_JDC.JDC,V_JDC.JDC,N_JDC.JDC):
       V_JDC.JDC.__init__(self)
       I_JDC.JDC.__init__(self)
       jdc.JDC.__init__(self)
+      self.icmd=0
diff --git a/Noyau/N_ASSD.py b/Noyau/N_ASSD.py
index fb7d93c6..95174231 100644
--- a/Noyau/N_ASSD.py
+++ b/Noyau/N_ASSD.py
@@ -59,6 +59,11 @@ class ASSD(object):
       self.executed = 0
       # permet de savoir si le catalogue de SD a déjà été supprimé (1) ou non (0)
       self.sd_deleted = 0
+      if self.parent:
+          self.order = self.parent.icmd
+      else:
+          self.order = 0
+
       # attributs pour le Catalogue de Structure de Données Jeveux
       # "self.cata_sdj" est un attribut de classe
       self.ptr_class_sdj = None
diff --git a/Noyau/N_ENTITE.py b/Noyau/N_ENTITE.py
index d99ab73a..eb5c296e 100644
--- a/Noyau/N_ENTITE.py
+++ b/Noyau/N_ENTITE.py
@@ -17,8 +17,6 @@
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
-
-
 """
     Ce module contient la classe ENTITE qui est la classe de base
     de toutes les classes de definition d'EFICAS.
@@ -93,8 +91,8 @@ class ENTITE:
       for k,v in self.entites.items() :
          try :
             cr = v.report()
-            cr.debut = "Début "+v.__class__.__name__+ ' : ' + k
-            cr.fin = "Fin "+v.__class__.__name__+ ' : ' + k
+            cr.debut = u"Début "+v.__class__.__name__+ ' : ' + k
+            cr.fin = u"Fin "+v.__class__.__name__+ ' : ' + k
             self.cr.add(cr)
          except:
             self.cr.fatal(_(u"Impossible d'obtenir le rapport de %s %s"), k,`v`)
@@ -142,8 +140,8 @@ class ENTITE:
             mcbloc = val.check_definition(parent)
             #XXX
             #print "#BLOC", parent, re.sub('\s+', ' ', val.condition)
-            #assert mcs.isdisjoint(mcbloc), "Commande %s : Mot(s)-clef(s) vu(s) plusieurs fois : %s" \
-            #   % (parent, tuple(mcs.intersection(mcbloc)))
+            assert mcs.isdisjoint(mcbloc), "Commande %s : Mot(s)-clef(s) vu(s) plusieurs fois : %s" \
+               % (parent, tuple(mcs.intersection(mcbloc)))
       return mcs
 
    def check_op(self, valmin=-9999, valmax=9999):
diff --git a/Noyau/N_ETAPE.py b/Noyau/N_ETAPE.py
index f932e6da..61b89f27 100644
--- a/Noyau/N_ETAPE.py
+++ b/Noyau/N_ETAPE.py
@@ -47,46 +47,43 @@ class ETAPE(N_MCCOMPO.MCCOMPO):
    # On le met à None pour indiquer qu'il n'y a pas de module de calcul rattaché
    codex=None
 
-   def __init__(self,oper=None,reuse=None,args={}):
-      """
-         Attributs :
-
-          - definition : objet portant les attributs de définition d'une etape de type opérateur. Il
-                         est initialisé par l'argument oper.
-
-          - reuse : indique le concept d'entrée réutilisé. Il se trouvera donc en sortie
-                    si les conditions d'exécution de l'opérateur l'autorise
-
-          - valeur : arguments d'entrée de type mot-clé=valeur. Initialisé avec l'argument args.
-
-      """
-      self.definition=oper
-      self.reuse=reuse
-      self.valeur=args
+   def __init__(self, oper=None, reuse=None, args={}, niveau=4):
+      """
+      Attributs :
+       - definition : objet portant les attributs de définition d'une étape de type opérateur. Il
+                      est initialisé par l'argument oper.
+       - reuse : indique le concept d'entrée réutilisé. Il se trouvera donc en sortie
+                 si les conditions d'exécution de l'opérateur l'autorise
+       - valeur : arguments d'entrée de type mot-clé=valeur. Initialisé avec l'argument args.
+      """
+      self.definition = oper
+      self.reuse = reuse
+      self.valeur = args
       self.nettoiargs()
-      self.parent=CONTEXT.get_current_step()
+      self.parent = CONTEXT.get_current_step()
       self.etape = self
-      self.nom=oper.nom
-      self.idracine=oper.label
-      self.appel=N_utils.callee_where()
-      self.mc_globaux={}
-      self.sd=None
-      self.actif=1
+      self.nom = oper.nom
+      self.idracine = oper.label
+      self.appel = N_utils.callee_where(niveau)
+      self.mc_globaux = {}
+      self.sd = None
+      self.actif = 1
       self.make_register()
+      self.icmd = None
 
    def make_register(self):
       """
-         Initialise les attributs jdc, id, niveau et réalise les
-         enregistrements nécessaires
+      Initialise les attributs jdc, id, niveau et réalise les
+      enregistrements nécessaires
       """
       if self.parent :
          self.jdc = self.parent.get_jdc_root()
-         self.id=self.parent.register(self)
-         self.niveau=None
+         self.id = self.parent.register(self)
+         self.niveau = None
       else:
-         self.jdc = self.parent =None
-         self.id=None
-         self.niveau=None
+         self.jdc = self.parent = None
+         self.id = None
+         self.niveau = None
 
    def nettoiargs(self):
       """
@@ -108,14 +105,14 @@ class ETAPE(N_MCCOMPO.MCCOMPO):
          Construit le concept produit de l'opérateur. Deux cas
          peuvent se présenter :
 
-           - le parent n'est pas défini. Dans ce cas, l'etape prend en charge la création
+           - le parent n'est pas défini. Dans ce cas, l'étape prend en charge la création
              et le nommage du concept.
 
-           - le parent est défini. Dans ce cas, l'etape demande au parent la création et
+           - le parent est défini. Dans ce cas, l'étape demande au parent la création et
              le nommage du concept.
 
       """
-      message.debug(SUPERV, "Build_sd %s", self.nom)
+      #message.debug(SUPERV, "Build_sd %s", self.nom)
       self.sdnom=nom
       try:
          if self.parent:
@@ -154,14 +151,14 @@ class ETAPE(N_MCCOMPO.MCCOMPO):
 
    def get_sd_prod(self):
       """
-          Retourne le concept résultat de l'etape
+          Retourne le concept résultat de l'étape
           Deux cas :
                    - cas 1 : sd_prod de oper n'est pas une fonction
                      il s'agit d'une sous classe de ASSD
                      on construit le sd à partir de cette classe
                      et on le retourne
                    - cas 2 : il s'agit d'une fonction
-                     on l'évalue avec les mots-clés de l'etape (mc_liste)
+                     on l'évalue avec les mots-clés de l'étape (mc_liste)
                      on construit le sd à partir de la classe obtenue
                      et on le retourne
       """
@@ -207,13 +204,13 @@ Causes possibles :
 
    def get_type_produit_brut(self):
       """
-          Retourne le type du concept résultat de l'etape
+          Retourne le type du concept résultat de l'étape
           Deux cas :
             - cas 1 : sd_prod de oper n'est pas une fonction
               il s'agit d'une sous classe de ASSD
               on retourne le nom de la classe
             - cas 2 : il s'agit d'une fonction
-              on l'évalue avec les mots-clés de l'etape (mc_liste)
+              on l'évalue avec les mots-clés de l'étape (mc_liste)
               et on retourne son résultat
       """
       if type(self.definition.sd_prod) == types.FunctionType:
@@ -225,10 +222,9 @@ Causes possibles :
 
    def get_etape(self):
       """
-         Retourne l'etape à laquelle appartient self
+         Retourne l'étape à laquelle appartient self
          Un objet de la catégorie etape doit retourner self pour indiquer que
-         l'etape a été trouvée
-         XXX fait double emploi avec self.etape ????
+         l'étape a été trouvée
       """
       return self
 
@@ -246,9 +242,23 @@ Causes possibles :
       if self.sd:
          self.sd.supprime()
 
+   def __del__(self):
+      #message.debug(SUPERV, "__del__ ETAPE %s <%s>", getattr(self, 'nom', 'unknown'), self)
+      #if self.sd:
+         #message.debug(SUPERV, "            sd : %s", self.sd.nom)
+      pass
+
+   def get_created_sd(self):
+      """Retourne la liste des sd réellement produites par l'étape.
+      Si reuse est présent, `self.sd` a été créée avant, donc n'est pas dans
+      cette liste."""
+      if not self.reuse and self.sd:
+          return [self.sd, ]
+      return []
+
    def isactif(self):
       """
-         Indique si l'etape est active (1) ou inactive (0)
+         Indique si l'étape est active (1) ou inactive (0)
       """
       return self.actif
 
@@ -257,10 +267,10 @@ Causes possibles :
           Methode utilisee pour que l etape self se declare etape
           courante. Utilise par les macros
       """
-      message.debug(SUPERV, "call etape.set_current_step", stack_id=-1)
+      #message.debug(SUPERV, "call etape.set_current_step", stack_id=-1)
       cs= CONTEXT.get_current_step()
-      if self.parent != cs and cs is not None:
-         raise AsException("L'etape courante", cs.nom, cs,
+      if self.parent != cs :
+         raise AsException("L'étape courante", cs.nom, cs,
                            "devrait etre le parent de", self.nom, self)
       else :
          CONTEXT.unset_current_step()
@@ -272,8 +282,8 @@ Causes possibles :
             etape courante
       """
       cs= CONTEXT.get_current_step()
-      if self != cs and cs is not None:
-         raise AsException("L'etape courante", cs.nom, cs,
+      if self != cs :
+         raise AsException("L'étape courante", cs.nom, cs,
                            "devrait etre", self.nom, self)
       else :
          CONTEXT.unset_current_step()
@@ -285,7 +295,7 @@ Causes possibles :
           sous etape de self ou non
           1 = oui
           0 = non
-          Une etape simple n'a pas de sous etape
+          Une étape simple n'a pas de sous etape
       """
       return 0
 
@@ -345,13 +355,13 @@ Causes possibles :
       return etape
 
    def copy_reuse(self,old_etape):
-      """ Méthode qui copie le reuse d'une autre etape.
+      """ Méthode qui copie le reuse d'une autre étape.
       """
       if hasattr(old_etape,"reuse") :
         self.reuse = old_etape.reuse
 
    def copy_sdnom(self,old_etape):
-      """ Méthode qui copie le sdnom d'une autre etape.
+      """ Méthode qui copie le sdnom d'une autre étape.
       """
       if hasattr(old_etape,"sdnom") :
         self.sdnom = old_etape.sdnom
@@ -387,8 +397,8 @@ Causes possibles :
    def full_copy(self,parent=None):
        """
           Méthode permettant d'effectuer une copie complète
-          d'une etape (y compris concept produit, éléments internes)
-          Si l'argument parent est fourni, la nouvelle etape
+          d'une étape (y compris concept produit, éléments internes)
+          Si l'argument parent est fourni, la nouvelle étape
           aura cet objet comme parent.
        """
        new_etape = self.copy()
@@ -412,7 +422,6 @@ Causes possibles :
        if self.sd and self.reuse == None :
            self.parent.NommerSdprod(self.sd,self.sd.nom)
 
-
    def is_include(self):
       """Permet savoir si on a affaire à la commande INCLUDE
       car le comportement de ces macros est particulier.
@@ -420,7 +429,7 @@ Causes possibles :
       return self.nom.startswith('INCLUDE')
 
    def sd_accessible(self):
-      """Dit si on peut acceder aux "valeurs" (jeveux) de l'ASSD produite par l'etape.
+      """Dit si on peut acceder aux "valeurs" (jeveux) de l'ASSD produite par l'étape.
       """
       if CONTEXT.debug: print '`- ETAPE sd_accessible :', self.nom
       return self.parent.sd_accessible()
diff --git a/Noyau/N_FACT.py b/Noyau/N_FACT.py
index dcb599d2..7e3c35f4 100644
--- a/Noyau/N_FACT.py
+++ b/Noyau/N_FACT.py
@@ -18,6 +18,7 @@
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+
 """ Ce module contient la classe de definition FACT
     qui permet de spécifier les caractéristiques des mots clés facteurs
 """
@@ -124,16 +125,20 @@ class FACT(N_ENTITE.ENTITE):
       # On cree toujours une liste de mcfact
       l=self.list_instance()
       l.init(nom = nom,parent=parent)
-      if type(val) in (types.TupleType,types.ListType) :
+      if type(val) in (types.TupleType, types.ListType, self.list_instance) :
          for v in val:
             if type(v) == types.DictType or isinstance(v, _F):
                objet=self.class_instance(nom=nom,definition=self,val=v,parent=parent)
                l.append(objet)
+            elif isinstance(v, self.class_instance):
+               l.append(v)
             else:
                l.append(N_OBJECT.ErrorObj(self,v,parent,nom))
       elif type(val) == types.DictType or isinstance(val, _F):
          objet=self.class_instance(nom=nom,definition=self,val=val,parent=parent)
          l.append(objet)
+      elif isinstance(val, self.class_instance):
+         l.append(val)
       else:
          l.append(N_OBJECT.ErrorObj(self,val,parent,nom))
 
diff --git a/Noyau/N_FONCTION.py b/Noyau/N_FONCTION.py
index 597c3352..0c1bcd74 100644
--- a/Noyau/N_FONCTION.py
+++ b/Noyau/N_FONCTION.py
@@ -22,6 +22,8 @@
 # de la division réelle pour les entiers, et non la division entière
 # 1/2=0.5 (et non 0). Comportement par défaut dans Python 3.0.
 from __future__ import division
+from math import sin, cos, tan, asin, acos, atan2, atan, sinh, cosh, tanh
+from math import pi, exp, log, log10, sqrt
 
 from N_ASSD import ASSD
 from N_info import message, SUPERV
@@ -42,16 +44,13 @@ class formule(ASSD):
 
     def __call__(self, *val):
         """Evaluation de la formule"""
-        from math import sin, cos, tan, asin, acos, atan2, atan, sinh, cosh, tanh
-        from math import pi ,exp,log, log10, sqrt
-        context = locals().copy()
         # en POURSUITE, self.parent_context is None, on essaie de reprendre const_context
-        context.update(getattr(self, 'parent_context') \
-                    or getattr(self.parent, 'const_context', {}))
+        context = getattr(self, 'parent_context') or getattr(self.parent, 'const_context', {})
         for param, value in zip(self.nompar, val):
             context[param] = value
         try:
-            res = eval(self.expression, context)
+            # globals() pour math.*
+            res = eval(self.code, context, globals())
         except Exception, exc:
             message.error(SUPERV, "ERREUR LORS DE L'ÉVALUATION DE LA FORMULE '%s' " \
                           ":\n>> %s",self.nom, str(exc))
diff --git a/Noyau/N_GEOM.py b/Noyau/N_GEOM.py
index f9128b45..3beb45ea 100644
--- a/Noyau/N_GEOM.py
+++ b/Noyau/N_GEOM.py
@@ -18,6 +18,7 @@
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+
 """
 
 """
@@ -55,7 +56,7 @@ class GEOM(ASSD):
    def __convert__(cls,valeur):
       if isinstance(valeur, (str,unicode)) and len(valeur.strip()) <= 8:
          return valeur.strip()
-      raise ValueError, 'On attend un chaine de caractères (de longueur < 8).'
+      raise ValueError(_(u'On attend une chaine de caractères (de longueur < 8).'))
    __convert__=classmethod(__convert__)
 
 class geom(GEOM):pass
diff --git a/Noyau/N_JDC.py b/Noyau/N_JDC.py
index fb1d30fd..13d2abd8 100644
--- a/Noyau/N_JDC.py
+++ b/Noyau/N_JDC.py
@@ -18,6 +18,7 @@
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+
 """
    Ce module contient la classe JDC qui sert à interpréter un jeu de commandes
 """
@@ -556,9 +557,23 @@ Causes possibles :
 
    def get_concept(self, nomsd):
       """
-          Méthode pour recuperer un concept à partir de son nom
+          Méthode pour récuperer un concept à partir de son nom
+      """
+      co = self.get_contexte_courant().get(nomsd.strip(), None)
+      if not isinstance(co, ASSD):
+          co = None
+      return co
+
+   def get_concept_by_type(self, nomsd, typesd, etape):
+      """
+          Méthode pour récuperer un concept à partir de son nom et de son type.
+          Il aura comme père 'etape'.
       """
-      return self.get_contexte_courant().get(nomsd.strip(), None)
+      assert issubclass(typesd, ASSD), typesd
+      co = typesd(etape=etape)
+      co.set_name(nomsd)
+      co.executed = 1
+      return co
 
    def del_concept(self, nomsd):
       """
diff --git a/Noyau/N_JDC_CATA.py b/Noyau/N_JDC_CATA.py
index df95c591..73e60999 100644
--- a/Noyau/N_JDC_CATA.py
+++ b/Noyau/N_JDC_CATA.py
@@ -17,6 +17,9 @@
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
+#
+# ======================================================================
+
 
 """
     Ce module contient la classe de definition JDC_CATA
@@ -104,13 +107,13 @@ class JDC_CATA(N_ENTITE.ENTITE):
       """
          Methode pour produire un compte-rendu de validation d'un catalogue de commandes
       """
-      self.cr = self.CR(debut = "Compte-rendu de validation du catalogue "+self.code,
-                        fin = "Fin Compte-rendu de validation du catalogue "+self.code)
+      self.cr = self.CR(debut = u"Compte-rendu de validation du catalogue "+self.code,
+                        fin = u"Fin Compte-rendu de validation du catalogue "+self.code)
       self.verif_cata()
       for commande in self.commandes:
         cr = commande.report()
         cr.debut = u"Début Commande :"+commande.nom
-        cr.fin = "Fin commande :"+commande.nom
+        cr.fin = u"Fin commande :"+commande.nom
         self.cr.add(cr)
       return self.cr
 
diff --git a/Noyau/N_MACRO.py b/Noyau/N_MACRO.py
index 5fa9d01f..a6b86353 100644
--- a/Noyau/N_MACRO.py
+++ b/Noyau/N_MACRO.py
@@ -18,6 +18,7 @@
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+
 """
     Ce module contient la classe de definition MACRO
     qui permet de spécifier les caractéristiques d'une macro-commande
@@ -135,15 +136,8 @@ class MACRO(N_ENTITE.ENTITE):
           Construit l'objet MACRO_ETAPE a partir de sa definition (self),
           puis demande la construction de ses sous-objets et du concept produit.
       """
-      # Glut MC (2007-05) / Sensibilité
-      # Précaution nécessaire pour la sensibilité (on fait 'exec' du texte d'une commande)
-      # car on n'a pas de "ligne" à décoder pour trouver le nom du résultat (à gauche
-      # du signe égal). Cà tombe bien, dans ce cas, sd_prod=None : pas de résultat !
-      if self.sd_prod != None:
-         nomsd=self.nommage.GetNomConceptResultat(self.nom)
-      else:
-         nomsd = None
-      etape= self.class_instance(oper=self,reuse=reuse,args=args)
+      nomsd = self.nommage.GetNomConceptResultat(self.nom)
+      etape = self.class_instance(oper=self,reuse=reuse,args=args)
       etape.McBuild()
       return etape.Build_sd(nomsd)
 
diff --git a/Noyau/N_MCCOMPO.py b/Noyau/N_MCCOMPO.py
index 104e67dd..59d66372 100644
--- a/Noyau/N_MCCOMPO.py
+++ b/Noyau/N_MCCOMPO.py
@@ -18,6 +18,7 @@
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+
 """
     Ce module contient la classe MCCOMPO qui sert à factoriser les comportements
     des OBJECT composites
@@ -396,8 +397,8 @@ class MCCOMPO(N_OBJECT.OBJECT):
               trouve des sd ; la valeur est la liste des sd attenante.
               Exemple ::
 
-                { 'VALE_F': [ <Cata.cata.para_sensi instance at 0x9419854>,
-                              <Cata.cata.para_sensi instance at 0x941a204> ],
+                { 'VALE_F': [ <Cata.cata.fonction_sdaster instance at 0x9419854>,
+                              <Cata.cata.fonction_sdaster instance at 0x941a204> ],
                   'MODELE': [<Cata.cata.modele instance at 0x941550c>] }
       """
       dico = {}
diff --git a/Noyau/N_MCLIST.py b/Noyau/N_MCLIST.py
index 5c13ad68..7182efed 100644
--- a/Noyau/N_MCLIST.py
+++ b/Noyau/N_MCLIST.py
@@ -18,6 +18,7 @@
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+
 """ 
     Ce module contient la classe MCList qui sert à controler la valeur
     d'une liste de mots-clés facteur par rapport à sa définition portée par un objet
@@ -130,8 +131,8 @@ class MCList(UserList.UserList):
 
               Exemple ::
               
-                { 'VALE_F': [ <Cata.cata.para_sensi instance at 0x9419854>,
-                              <Cata.cata.para_sensi instance at 0x941a204> ],
+                { 'VALE_F': [ <Cata.cata.fonction_sdaster instance at 0x9419854>,
+                              <Cata.cata.fonction_sdaster instance at 0x941a204> ],
                   'MODELE': [<Cata.cata.modele instance at 0x941550c>] }
       """
       dico = {}
diff --git a/Noyau/N_MCSIMP.py b/Noyau/N_MCSIMP.py
index 26f78e0c..65895f50 100644
--- a/Noyau/N_MCSIMP.py
+++ b/Noyau/N_MCSIMP.py
@@ -18,6 +18,7 @@
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+
 """
     Ce module contient la classe MCSIMP qui sert à controler la valeur
     d'un mot-clé simple par rapport à sa définition portée par un objet
@@ -163,8 +164,8 @@ class MCSIMP(N_OBJECT.OBJECT):
               la liste des sd attenante.
 
               Exemple ::
-                      { 'VALE_F': [ <Cata.cata.para_sensi instance at 0x9419854>,
-                                    <Cata.cata.para_sensi instance at 0x941a204> ] }
+                      { 'VALE_F': [ <Cata.cata.fonction_sdaster instance at 0x9419854>,
+                                    <Cata.cata.fonction_sdaster instance at 0x941a204> ] }
       """
       l=self.get_sd_utilisees()
       dico = {}
diff --git a/Noyau/N_OBJECT.py b/Noyau/N_OBJECT.py
index 6e997ddb..4b5470c8 100644
--- a/Noyau/N_OBJECT.py
+++ b/Noyau/N_OBJECT.py
@@ -18,6 +18,7 @@
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+
 """
     Ce module contient la classe OBJECT classe mère de tous les objets
     servant à controler les valeurs par rapport aux définitions
@@ -122,8 +123,8 @@ class ErrorObj(OBJECT):
     def report(self):
       """ génère le rapport de validation de self """
       self.cr=CR()
-      self.cr.debut = ufmt(_(u"Mot-clé invalide : %s"), self.nom)
-      self.cr.fin = ufmt(_(u"Fin Mot-clé invalide : %s"), self.nom)
+      self.cr.debut = u"Mot-clé invalide : "+self.nom
+      self.cr.fin = u"Fin Mot-clé invalide : "+self.nom
       self.cr.fatal(_(u"Type non autorisé pour le mot-clé %s : '%s'"),
                         self.nom, self.valeur)
       return self.cr
diff --git a/Noyau/N_PROC_ETAPE.py b/Noyau/N_PROC_ETAPE.py
index 36ba1b76..46fd2917 100644
--- a/Noyau/N_PROC_ETAPE.py
+++ b/Noyau/N_PROC_ETAPE.py
@@ -48,7 +48,7 @@ class PROC_ETAPE(N_ETAPE.ETAPE):
        - valeur : arguments d'entrée de type mot-clé=valeur. Initialisé avec l'argument args.
        - reuse : forcément None pour une PROC
       """
-      N_ETAPE.ETAPE.__init__(self, oper, reuse=None, args=args)
+      N_ETAPE.ETAPE.__init__(self, oper, reuse=None, args=args, niveau=5)
       self.reuse = None
 
    def Build_sd(self):
diff --git a/Noyau/N_VALIDATOR.py b/Noyau/N_VALIDATOR.py
index a87f49ad..97d25945 100644
--- a/Noyau/N_VALIDATOR.py
+++ b/Noyau/N_VALIDATOR.py
@@ -17,7 +17,6 @@
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
-
 """
    Ce module contient toutes les classes necessaires pour
    implanter le concept de validateur dans Accas
@@ -26,7 +25,7 @@ import types
 import traceback
 from N_ASSD import ASSD
 from N_types import is_int, is_float_or_int, is_complex, is_number, is_str, is_enum
-
+from strfunc import convert, ufmt
 
 class ValError(Exception):pass
 
@@ -116,7 +115,7 @@ class TypeProtocol(PProtocol):
 
     def default(self,obj,typ):
 
-        help = ""
+        err = ""
         for type_permis in typ:
             if type_permis == 'R':
                 if is_float_or_int(obj): return obj
@@ -132,31 +131,32 @@ class TypeProtocol(PProtocol):
                  import os
                  if (len(typ) > 2 and typ[2] == "Sauvegarde") or os.path.isfile(obj):
                      return obj
-                 else : raise ValError("%s n'est pas un fichier valide" % repr(obj))
+                 else : raise ValError(ufmt(_(u"%s n'est pas un fichier valide"), repr(obj)))
             elif type_permis == 'FichierNoAbs' :
                  import os
                  if (len(typ) > 2 and typ[2] == "Sauvegarde") or isinstance(obj, type("")):
                      return obj
-                 else : raise ValError("%s n'est pas un fichier valide" % repr(obj))
+                 else : raise ValError(ufmt(_(u"%s n'est pas un fichier valide"), repr(obj)))
             elif type_permis == 'Repertoire':
                 import os
                 if os.path.isdir(obj):
                     return obj
                 else:
-                    raise ValError(u"%s n'est pas un répertoire valide" % repr(obj))
+                    raise ValError(_(u"%s n'est pas un répertoire valide"), repr(obj))
             elif type(type_permis) == types.ClassType or isinstance(type_permis,type):
                 try:
                     if self.is_object_from(obj,type_permis): return obj
                 except Exception, err:
-                    help = str(err)
+                    pass
             elif type(type_permis) == types.InstanceType or isinstance(type_permis,object):
                 try:
                     if type_permis.__convert__(obj): return obj
                 except Exception, err:
-                    help = str(err)
+                    pass
             else:
-                print "Type non encore géré %s" %`type_permis`
-        raise ValError(u"%s (de type %s) n'est pas d'un type autorisé: %s %s" % (repr(obj),type(obj),typ, help))
+                print convert(ufmt(_(u"Type non encore géré %s"), `type_permis`))
+        raise ValError(ufmt(_(u"%s (de type %s) n'est pas d'un type autorisé: %s %s"),
+                            repr(obj), type(obj), typ, unicode(err)))
 
     def is_complexe(self,valeur):
         """ Retourne 1 si valeur est un complexe, 0 sinon """
@@ -209,7 +209,8 @@ class CardProtocol(PProtocol):
     def default(self,obj,min,max):
         length=len(obj)
         if length < min or length >max:
-            raise ValError("Nombre d'arguments de %s incorrect (min = %s, max = %s)" % (repr(obj),min,max) )
+            raise ValError(ufmt(_(u"Nombre d'arguments de %s incorrect (min = %s, max = %s)"),
+                           repr(obj), min, max))
         return obj
 
 class IntoProtocol(PProtocol):
@@ -224,14 +225,16 @@ class IntoProtocol(PProtocol):
     def default(self,obj,into,val_min,val_max):
         if into:
             if obj not in into:
-                raise ValError("La valeur : %s  ne fait pas partie des choix possibles %s" % (repr(obj),into) )
+                raise ValError(ufmt(_(u"La valeur : %s  ne fait pas partie des choix possibles %s"),
+                               repr(obj), into))
         else:
             #on est dans le cas d'un ensemble continu de valeurs possibles (intervalle)
             if is_float_or_int(obj):
                 if val_min == '**': val_min = obj -1
                 if val_max == '**': val_max = obj +1
                 if obj < val_min or obj > val_max :
-                    raise ValError("La valeur : %s est en dehors du domaine de validité [ %s , %s ]" % (repr(obj),self.val_min,self.val_max) )
+                    raise ValError(ufmt(_(u"La valeur : %s est en dehors du domaine de validité [ %s , %s ]"),
+                                   repr(obj), self.val_min, self.val_max))
         return obj
 
 class MinStr:
@@ -243,10 +246,11 @@ class MinStr:
 
     def __convert__(self,valeur):
         if is_str(valeur) and self.min <= len(valeur) <= self.max:return valeur
-        raise ValError("%s n'est pas une chaine de longueur comprise entre %s et %s" % (valeur,self.min,self.max))
+        raise ValError(ufmt(_(u"%s n'est pas une chaine de longueur comprise entre %s et %s"),
+                       valeur, self.min, self.max))
 
     def __repr__(self):
-        return "TXM de longueur entre %s et %s" %(self.min,self.max)
+        return ufmt(_(u"TXM de longueur entre %s et %s"), self.min, self.max)
 
 class Valid(PProtocol):
    """
@@ -268,7 +272,7 @@ class Valid(PProtocol):
           la validation demandée par le validateur. Elle est utilisée
           pour produire le compte-rendu de validité du mot clé associé.
        """
-       return "valeur valide"
+       return _(u"valeur valide")
 
    def aide(self):
        """
@@ -455,7 +459,7 @@ class Compulsory(ListVal):
           self.cata_info=""
 
       def info(self):
-          return "valeur %s obligatoire" % `self.elem`
+          return ufmt(_(u"valeur %s obligatoire"), `self.elem`)
 
       def default(self,valeur,elem):
           return valeur
@@ -469,7 +473,8 @@ class Compulsory(ListVal):
               v=self.adapt(val)
               if v in elem:elem.remove(v)
           if elem:
-              raise ValError("%s ne contient pas les elements obligatoires : %s " %(valeur,elem))
+              raise ValError(ufmt(_(u"%s ne contient pas les elements obligatoires : %s "),
+                             valeur, elem))
           return valeur
 
       def has_into(self):
@@ -485,7 +490,7 @@ class Compulsory(ListVal):
           return 1
 
       def info_erreur_item(self):
-          return "La valeur n'est pas dans la liste des choix possibles"
+          return _(u"La valeur n'est pas dans la liste des choix possibles")
 
 class NoRepeat(ListVal):
       """
@@ -497,13 +502,14 @@ class NoRepeat(ListVal):
           self.cata_info=""
 
       def info(self):
-          return ": pas de présence de doublon dans la liste"
+          return _(u": pas de présence de doublon dans la liste")
 
       def info_erreur_liste(self):
-          return "Les doublons ne sont pas permis"
+          return _(u"Les doublons ne sont pas permis")
 
       def default(self,valeur):
-          if valeur in self.liste : raise ValError("%s est un doublon" % valeur)
+          if valeur in self.liste :
+              raise ValError(ufmt(_(u"%s est un doublon"), valeur))
           return valeur
 
       def convert(self,valeur):
@@ -553,10 +559,10 @@ class LongStr(ListVal):
           self.cata_info=""
 
       def info(self):
-          return "longueur de la chaine entre %s et %s" %(self.low,self.high)
+          return ufmt(_(u"longueur de la chaine entre %s et %s"), self.low, self.high)
 
       def info_erreur_item(self):
-          return "Longueur de la chaine incorrecte"
+          return _(u"Longueur de la chaine incorrecte")
 
       def convert(self,valeur):
           for val in valeur:
@@ -572,12 +578,12 @@ class LongStr(ListVal):
 
       def default(self,valeur,low,high):
           if not is_str(valeur):
-             raise ValError("%s n'est pas une string" % repr(valeur))
+             raise ValError(ufmt(_(u"%s n'est pas une chaine"), repr(valeur)))
           if valeur[0]=="'" and valeur[-1]=="'" :
              low=low+2
              high=high+2
           if len(valeur) < low or len(valeur) > high :
-             raise ValError("%s n'est pas de la bonne longueur" % repr(valeur))
+             raise ValError(ufmt(_(u"%s n'est pas de la bonne longueur"), repr(valeur)))
           return valeur
 
 class OnlyStr(ListVal):
@@ -590,10 +596,10 @@ class OnlyStr(ListVal):
           self.cata_info=""
 
       def info(self):
-          return "regarde si c'est une chaine"
+          return _(u"regarde si c'est une chaine")
 
       def info_erreur_item(self):
-          return "Ce n'est pas une chain"
+          return _(u"Ce n'est pas une chaine")
 
       def convert(self,valeur):
           for val in valeur:
@@ -609,7 +615,7 @@ class OnlyStr(ListVal):
 
       def default(self,valeur):
           if not is_str(valeur):
-             raise ValError("%s n'est pas une string" % repr(valeur))
+             raise ValError(ufmt(_(u"%s n'est pas une chaine"), repr(valeur)))
           return valeur
 
 class OrdList(ListVal):
@@ -623,10 +629,10 @@ class OrdList(ListVal):
           self.cata_info=""
 
       def info(self):
-          return "liste %s" % self.ord
+          return ufmt(_(u"liste %s"), self.ord)
 
       def info_erreur_liste(self) :
-          return "La liste doit etre en ordre "+self.ord
+          return ufmt(_(u"La liste doit etre en ordre %s"), self.ord)
 
       def convert(self,valeur):
           self.val=None
@@ -638,10 +644,10 @@ class OrdList(ListVal):
       def default(self,valeur,ord):
           if self.ord=='croissant':
               if self.val is not None and valeur<self.val:
-                  raise ValError("%s n'est pas par valeurs croissantes" % repr(self.liste))
+                  raise ValError(ufmt(_(u"%s n'est pas par valeurs croissantes"), repr(self.liste)))
           elif self.ord=='decroissant':
               if self.val is not None and valeur > self.val:
-                  raise ValError("%s n'est pas par valeurs decroissantes" % repr(self.liste))
+                  raise ValError(ufmt(_(u"%s n'est pas par valeurs decroissantes"), repr(self.liste)))
           self.val=valeur
           return valeur
 
@@ -694,7 +700,7 @@ class OrVal(Valid):
                  return validator.convert(valeur)
               except:
                  pass
-          raise ValError("%s n'est pas du bon type" % repr(valeur))
+          raise ValError(ufmt(_(u"%s n'est pas du bon type"), repr(valeur)))
 
       def info_erreur_item(self):
           l=[]
@@ -970,21 +976,21 @@ class RangeVal(ListVal):
       def __init__(self,low,high):
           self.low=low
           self.high=high
-          self.cata_info="%s doit etre inferieur a %s" %(low,high)
+          self.cata_info=ufmt(_(u"%s doit être inférieur a %s"), low,high)
 
       def info(self):
-          return "valeur dans l'intervalle %s , %s" %(self.low,self.high)
+          return ufmt(_(u"valeur dans l'intervalle %s , %s"), self.low, self.high)
 
       def convert_item(self,valeur):
           if valeur > self.low and valeur < self.high:return valeur
-          raise ValError("%s devrait etre comprise entre %s et %s" %(valeur,self.low,self.high))
+          raise ValError(ufmt(_(u"%s devrait être comprise entre %s et %s"),
+                              valeur, self.low, self.high))
 
       def verif_item(self,valeur):
           return valeur > self.low and valeur < self.high
 
       def info_erreur_item(self) :
-          return "La valeur doit etre comprise entre %s et %s" % (self.low,
-                                                                  self.high)
+          return ufmt(_(u"La valeur doit etre comprise entre %s et %s"), self.low, self.high)
 
       def verif_cata(self):
           if self.low > self.high : return 0
@@ -1001,13 +1007,14 @@ class CardVal(Valid):
       def __init__(self,min='**',max='**'):
           self.min=min
           self.max=max
-          self.cata_info="%s doit etre inferieur a %s" % (min,max)
+          self.cata_info= ufmt(_(u"%s doit etre inferieur a %s"), min,max)
 
       def info(self):
-          return "longueur de liste comprise entre  %s et %s" % (self.min,self.max)
+          return ufmt(_(u"longueur de liste comprise entre  %s et %s"), self.min, self.max)
 
       def info_erreur_liste(self):
-          return "Le cardinal de la liste doit etre compris entre %s et %s" % (self.min,self.max)
+          return ufmt(_(u"Le cardinal de la liste doit etre compris entre %s et %s"),
+                      self.min, self.max)
 
       def is_list(self):
           return self.max == '**' or self.max > 1
@@ -1031,8 +1038,10 @@ class CardVal(Valid):
              l=0
           else:
              l=1
-          if self.max != '**' and l > self.max:raise ValError("%s devrait etre de longueur inferieure a %s" %(valeur,self.max))
-          if self.min != '**' and l < self.min:raise ValError("%s devrait etre de longueur superieure a %s" %(valeur,self.min))
+          if self.max != '**' and l > self.max:
+              raise ValError(ufmt(_(u"%s devrait etre de longueur inferieure a %s"), valeur, self.max))
+          if self.min != '**' and l < self.min:
+              raise ValError(ufmt(_(u"%s devrait etre de longueur superieure a %s"), valeur, self.min))
           return valeur
 
       def verif_item(self,valeur):
@@ -1071,15 +1080,16 @@ class PairVal(ListVal):
           self.cata_info=""
 
       def info(self):
-          return "valeur paire"
+          return _(u"valeur paire")
 
       def info_erreur_item(self):
-          return "La valeur saisie doit etre paire"
+          return _(u"La valeur saisie doit etre paire")
 
       def convert(self,valeur):
           for val in valeur:
              v=self.adapt(val)
-             if v % 2 != 0:raise ValError("%s contient des valeurs non paires" % repr(valeur))
+             if v % 2 != 0:
+                 raise ValError(ufmt(_(u"%s contient des valeurs non paires"), repr(valeur)))
           return valeur
 
       def default(self,valeur):
@@ -1116,7 +1126,8 @@ class EnumVal(ListVal):
 
       def convert_item(self,valeur):
           if valeur in self.into:return valeur
-          raise ValError("%s contient des valeurs hors des choix possibles: %s " %(valeur,self.into))
+          raise ValError(ufmt(_(u"%s contient des valeurs hors des choix possibles: %s "),
+                              valeur, self.into))
 
       def verif_item(self,valeur):
           if valeur not in self.into:return 0
@@ -1136,7 +1147,7 @@ class EnumVal(ListVal):
           return liste_choix
 
       def info_erreur_item(self):
-          return "La valeur n'est pas dans la liste des choix possibles"
+          return _(u"La valeur n'est pas dans la liste des choix possibles")
 
 def ImpairVal(valeur):
     """
@@ -1166,7 +1177,7 @@ class F1Val(Valid):
           self.cata_info=""
 
       def info(self):
-          return "valeur %s pour la somme des cles A et B " % self.somme
+          return ufmt(_(u"valeur %s pour la somme des cles A et B "), self.somme)
 
       def verif(self,valeur):
           if is_enum(valeur):
@@ -1223,7 +1234,7 @@ class TypeVal(ListVal):
              self.coerce = self.identity
 
       def info(self):
-          return "valeur de %s" % self.aType
+          return ufmt(_(u"valeur de %s"), self.aType)
 
       def identity ( self, value ):
           if type( value ) == self.aType:
@@ -1263,12 +1274,12 @@ class InstanceVal(ListVal):
              #instance nouvelle mode
              aClass=type(aClass)
           else:
-             raise ValError("type non supporte")
+             raise ValError(_(u"type non supporté"))
 
           self.aClass=aClass
 
       def info(self):
-          return "valeur d'instance de %s" % self.aClass.__name__
+          return ufmt(_(u"valeur d'instance de %s"), self.aClass.__name__)
 
       def verif_item(self,valeur):
           if not isinstance(valeur,self.aClass): return 0
@@ -1281,10 +1292,10 @@ class VerifTypeTuple(Valid,ListVal) :
           self.cata_info=""
 
       def info(self):
-          return ": verifie les types dans un tuple"
+          return _(u": vérifie les types dans un tuple")
 
       def info_erreur_liste(self):
-          return "Les types entres  ne sont pas permis"
+          return _(u"Les types entrés ne sont pas permis")
 
       def default(self,valeur):
           #if valeur in self.liste : raise ValError("%s est un doublon" % valeur)
@@ -1295,11 +1306,11 @@ class VerifTypeTuple(Valid,ListVal) :
 
       def convert_item(self,valeur):
           if len(valeur) != len(self.typeDesTuples):
-             raise ValError("%s devrait etre de type  %s " %(valeur,self.typeDesTuples))
+             raise ValError(ufmt(_(u"%s devrait etre de type  %s "), valeur, self.typeDesTuples))
           for i in range(len(valeur)) :
               ok=self.verifType(valeur[i],self.typeDesTuples[i])
               if ok!=1 : 
-                 raise ValError("%s devrait etre de type  %s " %(valeur,self.typeDesTuples))
+                 raise ValError(ufmt(_(u"%s devrait etre de type  %s "), valeur, self.typeDesTuples))
           return valeur
 
       def verif_item(self,valeur):
@@ -1380,5 +1391,5 @@ class VerifExiste(ListVal) :
 
       def convert_item(self,valeur):
           if valeur in self.listeDesFreres : return valeur
-          raise ValError(str(valeur)+" n est pas dans " + str(self.listeDesFreres))
+          raise ValError(ufmt(_(u"%s n'est pas dans %s"), valeur, self.listeDesFreres))
 
diff --git a/Noyau/N_info.py b/Noyau/N_info.py
index 720e8f22..3998fccc 100644
--- a/Noyau/N_info.py
+++ b/Noyau/N_info.py
@@ -18,8 +18,7 @@
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
-"""
-Module to manage information printing : debug, info, error.
+"""Module to manage information printing : debug, info, error.
 Should replace 'print' and 'UTMESS' calls at least in the supervisor
 modules.
 Only used for debug right now.
@@ -32,7 +31,7 @@ import traceback
 from functools import partial
 from subprocess import Popen, PIPE
 
-from N_utils import Enum
+from N_utils import Enum, Singleton
 from strfunc import convert
 
 def default_print(text):
@@ -92,8 +91,10 @@ REGEXP_ORIG = re.compile('File [\'\"]*(.*?)[\'\"]*, *line ([0-9]+), *in (.*)')
 
 # slighty different and very simplier than logger objects
 # from the logging module.
-class InfoLevel(object):
+class InfoLevel(Singleton):
     """Store informations level."""
+    _singleton_id = 'N_info.InfoLevel'
+    
     def __init__(self, level):
         """Initialization"""
         self._parts = []
diff --git a/Noyau/N_utils.py b/Noyau/N_utils.py
index 535abd49..d70b8e15 100644
--- a/Noyau/N_utils.py
+++ b/Noyau/N_utils.py
@@ -173,6 +173,17 @@ def import_object(uri):
     return object
 
 
+class Singleton(object):
+    """Singleton implementation in python."""
+    # add _singleton_id attribute to the class to be independant of import path used
+    __inst = {}
+    def __new__(cls, *args, **kargs):
+        cls_id = getattr(cls, '_singleton_id', cls)
+        if Singleton.__inst.get(cls_id) is None:
+            Singleton.__inst[cls_id] = object.__new__(cls)
+        return Singleton.__inst[cls_id]
+
+
 class Enum(object):
     """
     This class emulates a C-like enum for python. It is initialized with a list
diff --git a/Noyau/nommage.py b/Noyau/nommage.py
index bc46ff60..67c2c143 100644
--- a/Noyau/nommage.py
+++ b/Noyau/nommage.py
@@ -1,4 +1,5 @@
 # -*- coding: iso-8859-1 -*-
+
 # Copyright (C) 2007-2012   EDF R&D
 #
 # This library is free software; you can redistribute it and/or
@@ -18,6 +19,7 @@
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+
 """
    Ce module sert à nommer les concepts produits par les commandes.
    Le nom du concept est obtenu en appelant la fonction GetNomConceptResultat
@@ -68,7 +70,6 @@ def _GetNomConceptResultat(ope, level=2):
   co = f.f_code
   filename = co.co_filename
   name = co.co_name
-  #print "NOMOP,FICHIER, LIGNE ",ope,filename,lineno
   #pattern pour identifier le debut de la commande
   pattern_oper=re.compile(regex1 % ope)
 
@@ -77,13 +78,10 @@ def _GetNomConceptResultat(ope, level=2):
     line = linecache.getline(filename, lineno)
     lineno=lineno-1
     if pattern_comment.match(line):continue
-    #print "LIGNE ",line
     list.append(line)
     if pattern_oper.search(line):
       l=pattern_oper.split(line)
       list.reverse()
-      #print "COMMANDE ",string.join(list)
-      #print "SPLIT ",l
       # On suppose que le concept resultat a bien ete
       # isole en tete de la ligne de source
       m=evalnom(string.strip(l[0]),f.f_locals)
@@ -102,13 +100,11 @@ def evalnom(text,d):
       evaluant la partie indice dans le contexte de l'appelant d
   """
   l=re.split('([\[\]]+)',text)
-  #print l
   if l[-1] == '' :l=l[:-1]
   lll=[]
   i=0
   while i<len(l):
     s=l[i]
-    ll=string.split(s,',')
     ll=re.split('[ ,]+',s)
     if ll[0] == '' :ll=ll[1:]
     if len(ll) == 1:
@@ -146,8 +142,10 @@ def f_lineno(f):
    return line
 
 
-class NamingSystem:
+class NamingSystem(N_utils.Singleton):
     """Cette classe définit un système de nommage dynamique des concepts."""
+    _singleton_id = 'nommage.NamingSystem'
+    
     def __init__(self):
         """Initialisation"""
         self.native = _GetNomConceptResultat
diff --git a/Validation/V_ETAPE.py b/Validation/V_ETAPE.py
index cd3caa76..c3c7d6ca 100644
--- a/Validation/V_ETAPE.py
+++ b/Validation/V_ETAPE.py
@@ -18,6 +18,7 @@
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+
 """
    Ce module contient la classe mixin ETAPE qui porte les méthodes
    nécessaires pour réaliser la validation d'un objet de type ETAPE
@@ -72,6 +73,7 @@ class ETAPE(V_MCCOMPO.MCCOMPO):
              # la SD est 'sansnom' : --> erreur
              if cr == 'oui' :
                 self.cr.fatal(_(u"Pas de nom pour le concept retourné"))
+             valid = 0
           elif re.search('^SD_[0-9]*$', self.sd.nom):
              # la SD est 'SD_' cad son nom = son id donc pas de nom donné par utilisateur : --> erreur
              if cr == 'oui' :
@@ -218,10 +220,10 @@ class ETAPE(V_MCCOMPO.MCCOMPO):
       """
           Methode pour generation d un rapport de validite
       """
-      self.cr=self.CR(debut='Etape : '+self.nom \
-                + '    ligne : '+`self.appel[0]`\
-                + '    fichier : '+`self.appel[1]`,
-                 fin = 'Fin Etape : '+self.nom)
+      self.cr=self.CR(debut=u'Etape : '+self.nom \
+                + u'    ligne : '+`self.appel[0]`\
+                + u'    fichier : '+`self.appel[1]`,
+                 fin = u'Fin Etape : '+self.nom)
       self.state = 'modified'
       try:
         self.isvalid(cr='oui')
diff --git a/Validation/V_MCCOMPO.py b/Validation/V_MCCOMPO.py
index da13d28f..d3772b05 100644
--- a/Validation/V_MCCOMPO.py
+++ b/Validation/V_MCCOMPO.py
@@ -18,17 +18,19 @@
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+
 """
    Ce module contient la classe  de base MCCOMPO qui sert à factoriser
    les traitements des objets composites de type OBJECT
 """
 # Modules Python
+import os
 import traceback
 
 # Modules EFICAS
 from Noyau import N_CR
 from Noyau.N_Exception import AsException
-from Noyau.strfunc import ufmt
+from Noyau.strfunc import ufmt, to_unicode
 
 class MCCOMPO:
    """
@@ -39,7 +41,9 @@ class MCCOMPO:
    CR=N_CR.CR
 
    def __init__(self):
-      self.state='undetermined'
+      self.state = 'undetermined'
+      # défini dans les classes dérivées
+      self.txt_nat = ''
 
    def init_modif_up(self):
       """
@@ -55,7 +59,7 @@ class MCCOMPO:
       """
       self.cr=self.CR()
       self.cr.debut = self.txt_nat+self.nom
-      self.cr.fin = "Fin "+self.txt_nat+self.nom
+      self.cr.fin = u"Fin "+self.txt_nat+self.nom
       for child in self.mc_liste:
         self.cr.add(child.report())
       self.state = 'modified'
@@ -77,19 +81,17 @@ class MCCOMPO:
 
            - testglob = booléen 1 si toutes les règles OK, 0 sinon
       """
-      #dictionnaire=self.dict_mc_presents(restreint='oui')
-      dictionnaire=self.dict_mc_presents(restreint='non') # On verifie les regles avec les defauts affectés
-      texte='\n'
+      # On verifie les regles avec les defauts affectés
+      dictionnaire = self.dict_mc_presents(restreint='non')
+      texte = ['']
       testglob = 1
       for r in self.definition.regles:
-        erreurs,test=r.verif(dictionnaire)
+        erreurs,test = r.verif(dictionnaire)
         testglob = testglob*test
         if erreurs != '':
-          if len(texte) > 1 :
-            texte=texte+'\n'+erreurs
-          else :
-            texte = texte + erreurs
-      return texte,testglob
+            texte.append(to_unicode(erreurs))
+      texte = os.linesep.join(texte)
+      return texte, testglob
 
    def dict_mc_presents(self,restreint='non'):
       """