]> SALOME platform Git repositories - tools/eficas.git/commitdiff
Salome HOME
chgt noyau2 pour aster
authorpascale.noyret <pascale.noyret@edf.fr>
Wed, 28 Jan 2015 09:42:28 +0000 (10:42 +0100)
committerpascale.noyret <pascale.noyret@edf.fr>
Wed, 28 Jan 2015 09:42:28 +0000 (10:42 +0100)
Noyau/__init__.py
Noyau/ascheckers.py
Noyau/asnom.py
Noyau/asojb.py
Noyau/basetype.py
Noyau/context.py
Noyau/nommage.py
Noyau/strfunc.py

index 589d390f4a1b5fdd2f718d77eef79a7744fb5a01..beaec67ed81fe78831ef2c9c5397519c714c3d53 100644 (file)
@@ -1,4 +1,4 @@
-# -*- coding: iso-8859-1 -*-
+# coding=utf-8
 # Copyright (C) 2007-2013   EDF R&D
 #
 # This library is free software; you can redistribute it and/or
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
 
 
 """
     Ce package fournit les classes de base d'EFICAS.
-    Ces classes permettent d'effectuer quelques opérations basiques :
+    Ces classes permettent d'effectuer quelques opérations basiques :
 
-      - la création
+      - la création
 
-      - la vérification des définitions
+      - la vérification des définitions
 
-      - la création d'objets de type OBJECT à partir d'une définition de type ENTITE
+      - la création d'objets de type OBJECT à partir d'une définition de type ENTITE
 """
 # Avant toutes choses, on met le module context dans le global de l'interpreteur (__builtin__)
-# sous le nom CONTEXT afin d'avoir accès aux fonctions
-# get_current_step, set_current_step et unset_current_step de n'importe où
+# sous le nom CONTEXT afin d'avoir accès aux fonctions
+# get_current_step, set_current_step et unset_current_step de n'importe où
 import context
 import __builtin__
-__builtin__.CONTEXT=context
+__builtin__.CONTEXT = context
+
 
 def _(msg):
     """Differs translation."""
@@ -46,6 +46,14 @@ __builtin__._ = _
 from N_SIMP import SIMP
 from N_FACT import FACT
 
-# structures de données
+# structures de données
 import asojb
 from asojb import AsBase
+
+# Only the first MAXSIZE objects will be checked
+# This is used for the number of MCFACT, the number of MCSIMP and the number of
+# values in a MCSIMP.
+MAXSIZE = 500
+
+MAXSIZE_MSGCHK = ' <A> Only the first {0} occurrences (total: {1}) have been checked.'
+MAXSIZE_MSGKEEP = ' <A> Only the first {0} occurrences (total: {1}) have been kept.'
index 8ed138b3d5becb4671f6eab8cdcfc31098487e18..5bcbf9bd0edd9d373a1553175202e07d903d2ff3 100644 (file)
@@ -1,4 +1,4 @@
-# -*- coding: iso-8859-1 -*-
+# coding=utf-8
 # Copyright (C) 2007-2013   EDF R&D
 #
 # This library is free software; you can redistribute it and/or
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-
 class Parmi(object):
+
     """Classe qui exprime une contrainte multiple pour un attribut"""
+
     def __init__(self, *args):
         self.values = list(args)
 
-    def add_value(self, value ):
+    def add_value(self, value):
         if value not in self.values:
-            self.values.append( value )
+            self.values.append(value)
 
-    def __call__(self, obj, name, value, log ):
+    def __call__(self, obj, name, value, log):
         if value not in self.values:
-            log.err( obj, "l'attribut %s=%r n'est pas dans %r" % (name, value, self.values) )
+            log.err(obj, "l'attribut %s=%r n'est pas dans %r" %
+                    (name, value, self.values))
 
     def __repr__(self):
-        l = [ "Parmi(", ]
-        g = [ repr(v) for v in self.values ]
-        l.append( ", ".join(g) )
-        l.append( ")" )
-        return "".join( l )
+        l = ["Parmi(", ]
+        g = [repr(v) for v in self.values]
+        l.append(", ".join(g))
+        l.append(")")
+        return "".join(l)
+
 
 class CheckLog(object):
-    """Un validateur qui enregistre toutes les erreurs trouvées.
-    checkedXXX répond True si la "marq" courante est inférieure ou égale
-    à la celle de la dernière vérification.
-    Si on incrémentait "marq" à chaque étape, on revérifie à chaque fois.
+
+    """Un validateur qui enregistre toutes les erreurs trouvées.
+    checkedXXX répond True si la "marq" courante est inférieure ou égale
+    à la celle de la dernière vérification.
+    Si on incrémentait "marq" à chaque étape, on revérifie à chaque fois.
     """
 
     def __init__(self):
-        self.msg       = []
-        self.names     = {}
-        self.cksums    = {}
-        self.optional  = False
-        self._marq     = 1
+        self.msg = []
+        self.names = {}
+        self.cksums = {}
+        self.optional = False
+        self._marq = 1
         self._lastmarq = self._marq
-        self._debug    = False
-        self._profond  = False # True pour forcer des vérifications plus profondes
+        self._debug = False
+        self._profond = False  # True pour forcer des vérifications plus profondes
 
-    def log(self, level, obj, msg ):
-        if obj :
-            self.msg.append( (level, obj.nomj(), msg) )
-        else :
-            self.msg.append( (level, 'None', msg) )
+    def log(self, level, obj, msg):
+        if obj:
+            self.msg.append((level, obj.nomj(), msg))
+        else:
+            self.msg.append((level, 'None', msg))
 
-    def err(self, obj, msg ):
-        self.log( 0, obj, msg )
+    def err(self, obj, msg):
+        self.log(0, obj, msg)
 
-    def warn(self, obj, msg ):
-        self.log( 1, obj, msg )
+    def warn(self, obj, msg):
+        self.log(1, obj, msg)
 
     def visitOJB(self, obj):
         key = obj.nomj()
         self.names[key] = self._marq
 
     def checkSumOJB(self, obj, sd, maj='non'):
-        # vérifie que le checksum de obj n'a pas changé
+        # vérifie que le checksum de obj n'a pas changé
         # sd : concept qui contient obj
-        # maj='maj', l'opérateur a le droit de modifier ojb
-        if obj.exists :
+        # maj='maj', l'opérateur a le droit de modifier ojb
+        if obj.exists:
             import md5
-            m=md5.new()
+            m = md5.new()
             m.update(str(obj.get()))
-            cksum=m.digest()
-            nom=obj.nomj()
-            if not self.cksums.has_key(nom) :
-                self.cksums[nom]=cksum
-            else :
-                if self.cksums[nom] != cksum :
+            cksum = m.digest()
+            nom = obj.nomj()
+            if not self.cksums.has_key(nom):
+                self.cksums[nom] = cksum
+            else:
+                if self.cksums[nom] != cksum:
                     self.cksums[nom] = cksum
-                    #if maj.strip()=='maj' and nom[0:8].strip()==sd.nomj.nomj[0:8].strip() :
-                    # Remarque : ne pas tester 'maj' premet de résoudre (un peu) le problème
-                    #            posé par la commande DETRUIRE
-                    if nom[0:8].strip()==sd.nomj.nomj[0:8].strip() :
+                    # if maj.strip()=='maj' and nom[0:8].strip()==sd.nomj.nomj[0:8].strip() :
+                    # Remarque : ne pas tester 'maj' premet de résoudre (un peu) le problème
+                    #            posé par la commande DETRUIRE
+                    if nom[0:8].strip() == sd.nomj.nomj[0:8].strip():
                         pass
-                    else :
-                        self.err(obj,'Le checksum a changé')
+                    else:
+                        self.err(obj, 'Le checksum a changé')
 
     def visitAsBase(self, obj):
         key = (obj.nomj(), obj.__class__.__name__)
@@ -100,15 +103,15 @@ class CheckLog(object):
 
     def force(self, force=False):
         if not force:
-           self._marq = 1
+            self._marq = 1
         else:
-           self._lastmarq += 1
-           self._marq = self._lastmarq
+            self._lastmarq += 1
+            self._marq = self._lastmarq
 
     def checkedOJB(self, obj):
         key = obj.nomj()
         res = self.names.get(key, 0) >= self._marq
-        self.help_dbg([key,], res)
+        self.help_dbg([key, ], res)
         return res
 
     def checkedAsBase(self, obj):
@@ -120,18 +123,21 @@ class CheckLog(object):
     def help_dbg(self, key, res):
         if self._debug:
             if res:
-               s = 'ignore'
+                s = 'ignore'
             else:
-               s = 'check '
+                s = 'check '
             print '#DBG %6d %s : %s' % (self._marq, s, ', '.join(key))
 
     def __str__(self):
-        d = { 0: "E", 1:"W" }
-        return "\n".join( [ "%s:%s: %s" % (d[l],n,m)
-                            for l,n,m in self.msg ])
+        d = {0: "E", 1: "W"}
+        return "\n".join(["%s:%s: %s" % (d[l], n, m)
+                          for l, n, m in self.msg])
+
 
 class CheckFail(CheckLog):
-    """Un validateur qui lève une exception
-    dès la première erreur"""
-    def err(self, obj, msg ):
-        raise AssertionError("%s: %s" % (obj.nomj(), msg) )
+
+    """Un validateur qui lève une exception
+    dès la première erreur"""
+
+    def err(self, obj, msg):
+        raise AssertionError("%s: %s" % (obj.nomj(), msg))
index 370da21407c5efbf8cd525a9983b4e5e4b5aa68d..9ee9fd0eff6bd9e074d3813d4e3fb2c8ef887b99 100644 (file)
@@ -1,4 +1,4 @@
-# -*- coding: iso-8859-1 -*-
+# coding=utf-8
 # Copyright (C) 2007-2013   EDF R&D
 #
 # This library is free software; you can redistribute it and/or
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-
 """
 Description des types de base aster
 
-version 2 - réécrite pour essayer de simplifier
-le problème des instances/types et instances/instances
+version 2 - réécrite pour essayer de simplifier
+le problème des instances/types et instances/instances
 
-le type de base ASBase permet de représenter une structure
-de donnée. Une instance de ASBase comme attribut d'une classe
-dérivée de ASBase représente une sous-structure nommée.
+le type de base ASBase permet de représenter une structure
+de donnée. Une instance de ASBase comme attribut d'une classe
+dérivée de ASBase représente une sous-structure nommée.
 
-une instance de ASBase 'libre' représente une instance de la
-structure de donnée complète.
+une instance de ASBase 'libre' représente une instance de la
+structure de donnée complète.
 
-c'est ce comportement qui est capturé dans la classe StructType
+c'est ce comportement qui est capturé dans la classe StructType
 """
 
 from basetype import Type
 
+
 class SDNom(Type):
-    """Objet représentant une sous-partie de nom
+
+    """Objet représentant une sous-partie de nom
     d'objet jeveux"""
     nomj = None
     debut = None
@@ -45,28 +45,29 @@ class SDNom(Type):
     just = None
     justtype = None
 
-    def __init__(self, nomj=None, debut=None, fin=None, just='l', **kwargs ):
+    def __init__(self, nomj=None, debut=None, fin=None, just='l', **kwargs):
         """
         Configure un objet nom
-        nomj : la partie du nom fixée (par ex .TITR) ou '' si non précisée
-        debut, fin : la partie du K24 concernée
+        nomj : la partie du nom fixée (par ex .TITR) ou '' si non précisée
+        debut, fin : la partie du K24 concernée
         just : la justification a droite ou a gauche ('l' ou 'r')
-        kwargs : inutilisé, juste par simplicité
+        kwargs : inutilisé, juste par simplicité
 
         Note:
         On utilise cet objet comme attribut d'instance ou de classe.
         En attribut de classe pour les noms de structure, cela permet
-        de définir la position du nom d'objet dans le nom jeveux, l'attribut
+        de définir la position du nom d'objet dans le nom jeveux, l'attribut
         nom est alors la valeur du suffixe pour une sous-structure ou None pour
         une structure principale.
         """
-        super( SDNom, self ).__init__( nomj=nomj, debut=debut, fin=fin, just=just, **kwargs )
-        self.update( (nomj, debut, fin, just) )
+        super(SDNom, self).__init__(
+            nomj=nomj, debut=debut, fin=fin, just=just, **kwargs)
+        self.update((nomj, debut, fin, just))
 
     def __call__(self):
         if self._parent is None or self._parent._parent is None:
             debut = self.debut or 0
-            prefix = ' '*debut
+            prefix = ' ' * debut
         else:
             # normalement
             # assert self._parent.nomj is self
@@ -75,37 +76,36 @@ class SDNom(Type):
             debut = self.debut or nomparent.fin or len(prefix)
         fin = self.fin or 24
         nomj = self.nomj or ''
-        nomj = self.just( nomj, fin-debut )
+        nomj = self.just(nomj, fin - debut)
         prefix = prefix.ljust(24)
-        res = prefix[:debut]+nomj+prefix[fin:]
+        res = prefix[:debut] + nomj + prefix[fin:]
         return res[:24]
 
     def fcata(self):
-        return self.just(self.nomj,self.fin-self.debut).replace(' ','?')
+        return self.just(self.nomj, self.fin - self.debut).replace(' ', '?')
 
     def __repr__(self):
-        return "<SDNom(%r,%s,%s)>" % (self.nomj,self.debut,self.fin)
+        return "<SDNom(%r,%s,%s)>" % (self.nomj, self.debut, self.fin)
 
-    # On utilise pickle pour les copies, et pickle ne sait pas gérer la
-    # sauvegarde de str.ljust ou str.rjust (c'est une méthode non liée)
+    # On utilise pickle pour les copies, et pickle ne sait pas gérer la
+    # sauvegarde de str.ljust ou str.rjust (c'est une méthode non liée)
 
     def __getstate__(self):
-        return (self.nomj, self.debut, self.fin, self.justtype )
+        return (self.nomj, self.debut, self.fin, self.justtype)
 
-    def __setstate__( self, (nomj,debut,fin,just) ):
+    def __setstate__(self, (nomj, debut, fin, just)):
         self.nomj = nomj
         self.debut = debut
         self.fin = fin
-        if just=='l' or just is None:
+        if just == 'l' or just is None:
             self.just = str.ljust
-        elif just=='r':
+        elif just == 'r':
             self.just = str.rjust
         else:
-            raise ValueError("Justification '%s' invalide" % just )
+            raise ValueError("Justification '%s' invalide" % just)
         self.justtype = just
 
-
-    def update( self, (nomj,debut,fin,just) ):
+    def update(self, (nomj, debut, fin, just)):
         if nomj is not None:
             self.nomj = nomj
         if self.debut is None:
@@ -113,21 +113,19 @@ class SDNom(Type):
         if self.fin is None:
             self.fin = fin
         if self.justtype is None and just is not None:
-            if just=='l':
+            if just == 'l':
                 self.just = str.ljust
-            elif just=='r':
+            elif just == 'r':
                 self.just = str.rjust
             else:
-                raise ValueError("Justification '%s' invalide" % just )
+                raise ValueError("Justification '%s' invalide" % just)
             self.justtype = just
 
-    def reparent( self, parent, new_name ):
+    def reparent(self, parent, new_name):
         self._parent = parent
         self._name = new_name
         for nam in self._subtypes:
-            obj = getattr( self, nam )
-            obj.reparent( self, nam )
+            obj = getattr(self, nam)
+            obj.reparent(self, nam)
         if self.nomj is None and self._parent._name is not None:
             self.nomj = "." + self._parent._name
-
-
index 0eb259c5767c917dbac1a982a0fc94d038afe11f..b1c08bf5fac90ab9a01b4c29130147c09db8266c 100644 (file)
@@ -1,4 +1,4 @@
-# -*- coding: iso-8859-1 -*-
+# coding=utf-8
 # Copyright (C) 2007-2013   EDF R&D
 #
 # This library is free software; you can redistribute it and/or
@@ -16,7 +16,6 @@
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
 
 """
    Description des OJB jeveux
 from basetype import Type
 from asnom import SDNom
 from ascheckers import CheckLog
-import traceback,sys
+import traceback
+import sys
 
 # pour utilisation dans eficas
 try:
-   import aster
-   from Utilitai.Utmess import UTMESS
+    import aster
+    from Utilitai.Utmess import UTMESS
 except:
-   pass
+    pass
 
 # -----------------------------------------------------------------------------
+
+
 class AsBase(Type):
     nomj = SDNom()
     optional = False
 
-    def __init__(self, nomj=None, *args, **kwargs ):
-        super(AsBase,self).__init__( nomj, *args, **kwargs )
+    def __init__(self, nomj=None, *args, **kwargs):
+        super(AsBase, self).__init__(nomj, *args, **kwargs)
         assert self.nomj is not self.__class__.nomj
-        if isinstance( nomj, str ):
+        if isinstance(nomj, str):
             self.nomj.nomj = nomj
-        elif isinstance( nomj, SDNom ):
-            self.nomj.update( nomj.__getstate__() )
+        elif isinstance(nomj, SDNom):
+            self.nomj.update(nomj.__getstate__())
 
     def set_name(self, nomj):
         """Positionne le nomj de self
         """
-        assert isinstance( self.nomj.nomj, str ), "uniquement pour les concepts"
+        assert isinstance(self.nomj.nomj, str), "uniquement pour les concepts"
         self.nomj.nomj = nomj
 
     def check(self, checker=None):
         if checker is None:
             checker = CheckLog()
 
-        # vérif déjà faite ? (en tenant compte du type)
+        # vérif déjà faite ? (en tenant compte du type)
         if checker.checkedAsBase(self):
             return checker
-        checker.visitAsBase( self )
+        checker.visitAsBase(self)
 
-        # vérifie les enfants :
+        # vérifie les enfants :
         optional = checker.optional
         checker.optional = checker.optional or self.optional
         for name in self._subtypes:
             v = getattr(self, name)
-            if isinstance( v, (OJB,AsBase) ):
+            if isinstance(v, (OJB, AsBase)):
                 v.check(checker)
         for name in dir(self):
-            if name.startswith( 'check_' ):
+            if name.startswith('check_'):
                 v = getattr(self, name)
                 if callable(v):
-                    try :
-                        v( checker )
-                    except :
-                        mess=60*'-'+'\n'
-                        mess=mess+'Erreur SDVERI (Attention : vérification incomplète)'+'\n'
-                        mess=mess.join(traceback.format_tb(sys.exc_traceback))
-                        checker.err(self,mess)
+                    try:
+                        v(checker)
+                    except:
+                        mess = 60 * '-' + '\n'
+                        mess = mess + \
+                            'Erreur SDVERI (Attention : vérification incomplète)' + \
+                            '\n'
+                        mess = mess.join(
+                            traceback.format_tb(sys.exc_traceback))
+                        checker.err(self, mess)
 
         checker.optional = optional
         return checker
 
-    def members( self ):
-        pass
-
     def dump(self, indent=""):
         import pydoc
         l = []
@@ -95,66 +97,71 @@ class AsBase(Type):
             f = "(f)"
         else:
             f = "(o)"
-        l.append( f+" "+nomj )
-        #l.append( '-'*(len(nomj)+3) )
+        l.append(f + " " + nomj)
         for name in self._subtypes:
             obj = getattr(self, name)
-            if isinstance(obj,(AsBase,OJB)):
-                l.append( obj.dump(indent) )
+            if isinstance(obj, (AsBase, OJB)):
+                l.append(obj.dump(indent))
         for name in dir(self):
-            if name.startswith( 'check_' ):
+            if name.startswith('check_'):
                 obj = getattr(self, name)
                 if callable(obj) and name.startswith("check_"):
-                    checkers.append( obj )
+                    checkers.append(obj)
 
-        indent = " "*len(nomj)
+        indent = " " * len(nomj)
         for checker in checkers:
-            doc = pydoc.text.document( checker )
+            doc = pydoc.text.document(checker)
             for line in doc.splitlines():
-                l.append( indent + line )
-        return "\n".join( l )
+                l.append(indent + line)
+        return "\n".join(l)
 
     def short_repr(self):
-        return "<%s(%x,%r)>" % (self.__class__.__name__, id(self), self.nomj() )
+        return "<%s(%x,%r)>" % (self.__class__.__name__, id(self), self.nomj())
 
     def long_repr(self):
         if not hasattr(self, "accessible") or not self.accessible():
-           # hors Aster ou en par_lot='oui'
-           return self.short_repr()
+            # hors Aster ou en par_lot='oui'
+            return self.short_repr()
         else:
-           from Cata.cata import IMPR_CO, _F
-           IMPR_CO(CONCEPT=_F(NOM=self.nom), UNITE=6)
-           return ''
+            from Cata.cata import IMPR_CO, _F
+            IMPR_CO(CONCEPT=_F(NOM=self.nom), UNITE=6)
+            return ''
 
     def __repr__(self):
-        # par défaut, on fait court !
+        # par défaut, on fait court !
         return self.short_repr()
 
 
 # -----------------------------------------------------------------------------
 class JeveuxAttr(object):
+
     """Un attribut jeveux"""
+
     def __init__(self, name):
         self.name = name
 
     def __get__(self, obj, klass):
         raise NotImplementedError
 
-    def check(self, attrname, obj, log ):
-        checker = getattr(obj, "_"+attrname, None )
+    def check(self, attrname, obj, log):
+        checker = getattr(obj, "_" + attrname, None)
         if checker is None:
             return True
-        val = self.__get__( obj, obj.__class__ )
-        if callable( checker ):
-            return checker( obj, attrname, val, log )
+        val = self.__get__(obj, obj.__class__)
+        if callable(checker):
+            return checker(obj, attrname, val, log)
+        elif val == checker:
+            return True
         else:
-            test = val == checker
-            if not test:
-                log.err( obj, "Attribut incorrect %s %r!=%r" % (self.name, val, checker ) )
-            return test
+            log.err(obj, "Attribut incorrect %s %r!=%r" %
+                    (self.name, val, checker))
+            return False
 
 # -----------------------------------------------------------------------------
+
+
 class JeveuxExists(JeveuxAttr):
+
     def __init__(self):
         pass
 
@@ -162,33 +169,41 @@ class JeveuxExists(JeveuxAttr):
         if obj is None:
             return self
         nomj = obj.nomj()
-        if len(nomj)!=24:
+        if len(nomj) != 24:
             raise AssertionError(repr(nomj))
-        return aster.jeveux_exists( nomj.ljust(24) )
+        return aster.jeveux_exists(nomj.ljust(24))
 
 # -----------------------------------------------------------------------------
+
+
 class JeveuxIntAttr(JeveuxAttr):
+
     def __get__(self, obj, klass):
         if obj is None:
             return self
         nomj = obj.nomj()
-        if aster.jeveux_exists( nomj ):
-            return aster.jeveux_getattr( nomj, self.name )[0]
-        else :
+        if aster.jeveux_exists(nomj):
+            return aster.jeveux_getattr(nomj, self.name)[0]
+        else:
             return None
 
 # -----------------------------------------------------------------------------
+
+
 class JeveuxStrAttr(JeveuxAttr):
+
     def __get__(self, obj, klass):
         if obj is None:
             return self
         nomj = obj.nomj()
-        if aster.jeveux_exists( nomj ):
-            return aster.jeveux_getattr( nomj, self.name )[1].strip()
-        else :
+        if aster.jeveux_exists(nomj):
+            return aster.jeveux_getattr(nomj, self.name)[1].strip()
+        else:
             return None
 
 # -----------------------------------------------------------------------------
+
+
 class OJB(AsBase):
     _clas = None
     _genr = None
@@ -205,58 +220,57 @@ class OJB(AsBase):
     xous = JeveuxStrAttr("XOUS")
     docu = JeveuxStrAttr("DOCU")
     exists = JeveuxExists()
-    #optional = False
     nomj = SDNom()
 
     def __init__(self, nomj=None, **attrs):
-        super(OJB,self).__init__( nomj, **attrs )
-        self.foreachattr( self.setattribute, attrs )
+        super(OJB, self).__init__(nomj, **attrs)
+        self.foreachattr(self.setattribute, attrs)
         self.optional = attrs.get('optional', False)
 
-    def setattribute( self, name, prop, attrs ):
-        _name = "_"+name
+    def setattribute(self, name, prop, attrs):
+        _name = "_" + name
         if name in attrs:
-            setattr( self, _name, attrs[name] )
+            setattr(self, _name, attrs[name])
 
     def get(self):
         nomj = self.nomj()
-        if aster.jeveux_exists( nomj ):
-            obj_simple = aster.jeveux_getattr( nomj, 'XOUS')[1].strip() == 'S'
-            if obj_simple :
-                return aster.getvectjev( nomj )
-            else :
-                return aster.getcolljev( nomj )
+        if aster.jeveux_exists(nomj):
+            obj_simple = aster.jeveux_getattr(nomj, 'XOUS')[1].strip() == 'S'
+            if obj_simple:
+                return aster.getvectjev(nomj)
+            else:
+                return aster.getcolljev(nomj)
         else:
             return None
 
     def get_stripped(self):
-        """Fonction utilitaire, renvoie une liste de chaines 'strippées'"""
+        """Fonction utilitaire, renvoie une liste de chaines 'strippées'"""
         data = self.get()
         if data is not None:
-            return [ x.strip() for x in data ]
+            return [x.strip() for x in data]
         else:
             return []
 
     def foreachattr(self, callback, *args, **kwargs):
         klass = self.__class__
         for k in dir(klass):
-            v = getattr( klass, k )
+            v = getattr(klass, k)
             if isinstance(v, JeveuxAttr):
-                callback( k, v, *args, **kwargs )
+                callback(k, v, *args, **kwargs)
 
     def check(self, checker=None):
         if checker is None:
             checker = CheckLog()
-        # l'objet a déjà été vérifié, on ne fait rien
+        # l'objet a déjà été vérifié, on ne fait rien
         if checker.checkedOJB(self):
-           return checker
-        checker.visitOJB( self )
+            return checker
+        checker.visitOJB(self)
         if self.exists:
-            self.foreachattr( lambda k,v,obj,c: v.check(k, obj, c),
-                              self, checker )
+            self.foreachattr(lambda k, v, obj, c: v.check(k, obj, c),
+                             self, checker)
         else:
-            if not self.optional and not checker.optional :
-                checker.err( self, "n'existe pas (%r)" %self._parent )
+            if not self.optional and not checker.optional:
+                checker.err(self, "n'existe pas (%r)" % self._parent)
         return checker
 
     def dump(self, indent=""):
@@ -264,14 +278,18 @@ class OJB(AsBase):
             f = "(f)"
         else:
             f = "(o)"
-        return f +" "+ self.nomj() +" "+ str(self.exists)
+        return f + " " + self.nomj() + " " + str(self.exists)
 
 # -----------------------------------------------------------------------------
-def Facultatif( ojb ):
+
+
+def Facultatif(ojb):
     ojb.optional = True
     return ojb
 
 # -----------------------------------------------------------------------------
+
+
 class OJBVect(OJB):
     lonmax = JeveuxIntAttr("LONMAX")
     lonuti = JeveuxIntAttr("LONUTI")
@@ -279,6 +297,8 @@ class OJBVect(OJB):
     _genr = "V"
 
 # -----------------------------------------------------------------------------
+
+
 class OJBPtnom(OJB):
     nommax = JeveuxIntAttr("NOMMAX")
     nomuti = JeveuxIntAttr("NOMUTI")
@@ -287,60 +307,82 @@ class OJBPtnom(OJB):
     _type = "K"
 
 # -----------------------------------------------------------------------------
+
+
 class OJBCollec(OJB):
     stockage = JeveuxStrAttr("STOCKAGE")
-    nutioc = JeveuxIntAttr( "NUTIOC" )
-    acces = JeveuxStrAttr( "ACCES" )
-    modelong = JeveuxStrAttr( "MODELONG" )
-    nmaxoc = JeveuxIntAttr( "NMAXOC" )
+    nutioc = JeveuxIntAttr("NUTIOC")
+    acces = JeveuxStrAttr("ACCES")
+    modelong = JeveuxStrAttr("MODELONG")
+    nmaxoc = JeveuxIntAttr("NMAXOC")
 
 # -----------------------------------------------------------------------------
+
+
 class AsVI(OJBVect):
     _type = "I"
 
 # -----------------------------------------------------------------------------
+
+
 class AsVS(OJBVect):
     _type = "S"
 
 # -----------------------------------------------------------------------------
+
+
 class AsVR(OJBVect):
     _type = "R"
 
 # -----------------------------------------------------------------------------
+
+
 class AsVC(OJBVect):
     _type = "C"
 
 # -----------------------------------------------------------------------------
+
+
 class AsVL(OJBVect):
     _type = "L"
 
 # -----------------------------------------------------------------------------
+
+
 class AsVK8(OJBVect):
     _type = "K"
     _ltyp = 8
 
 # -----------------------------------------------------------------------------
+
+
 class AsVK16(OJBVect):
     _type = "K"
     _ltyp = 16
 
 # -----------------------------------------------------------------------------
+
+
 class AsVK24(OJBVect):
     _type = "K"
     _ltyp = 24
 
 # -----------------------------------------------------------------------------
+
+
 class AsVK32(OJBVect):
     _type = "K"
     _ltyp = 32
 
 # -----------------------------------------------------------------------------
+
+
 class AsVK80(OJBVect):
     _type = "K"
     _ltyp = 80
 
 # Pour compatibilite
 AsObject = OJB
-AsColl   = OJBCollec
-AsPn     = OJBPtnom
-AsVect   = OJBVect
+AsColl = OJBCollec
+AsPn = OJBPtnom
+AsVect = OJBVect
index b3fc2e69f7e923c95d85b62a06201395c70eab9b..57ab825156f1aec84ce24d7d85a083c110e34835 100644 (file)
@@ -1,4 +1,4 @@
-# -*- coding: iso-8859-1 -*-
+# coding=utf-8
 # Copyright (C) 2007-2013   EDF R&D
 #
 # This library is free software; you can redistribute it and/or
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
+
 """
+
 Description des types de base aster
 -----------------------------------
 
-version 2 - réécrite pour essayer de simplifier
-le problème des instances/types et instances/instances.
+version 2 - réécrite pour essayer de simplifier
+le problème des instances/types et instances/instances.
 
-Le type de base `Type` permet de représenter une structure
-de donnée. Une instance de `Type` comme attribut d'une classe
-dérivée de `Type` représente une sous-structure nommée.
+Le type de base `Type` permet de représenter une structure
+de donnée. Une instance de `Type` comme attribut d'une classe
+dérivée de `Type` représente une sous-structure nommée.
 
-Une instance de `Type` 'libre' représente une instance de la
-structure de donnée complète.
+Une instance de `Type` 'libre' représente une instance de la
+structure de donnée complète.
 
-C'est ce comportement qui est capturé dans la classe BaseType
+C'est ce comportement qui est capturé dans la classe BaseType
 
-La classe `Type` hérite de BaseType et y associe la métaclasse MetaType.
+La classe `Type` hérite de BaseType et y associe la métaclasse MetaType.
 
 """
 
@@ -42,41 +43,40 @@ import cPickle
 __docformat__ = "restructuredtext"
 
 
-
-
 class MetaType(type):
-    """Métaclasse d'un type représentant une structure de données.
-    Les méthodes spéciales __new__ et __call__ sont réimplémentées
+
+    """Métaclasse d'un type représentant une structure de données.
+    Les méthodes spéciales __new__ et __call__ sont réimplémentées
     """
-    def __new__( mcs, name, bases, classdict ):
-        """Création d'une nouvelle 'classe' dérivant de Type.
+    def __new__(mcs, name, bases, classdict):
+        """Création d'une nouvelle 'classe' dérivant de Type.
 
-        Cette méthode permet de calculer certains attributs automatiquement:
+        Cette méthode permet de calculer certains attributs automatiquement:
 
          - L'attribut _subtypes qui contient la liste des sous-structures
-           de type 'Type' attributs (directs ou hérités) de cette classe.
+           de type 'Type' attributs (directs ou hérités) de cette classe.
 
-        Pour chaque attribut de classe héritant de Type, on recrée une nouvelle
-        instance des attributs hérités pour pouvoir maintenir une structure de
-        parentée entre l'attribut de classe et sa nouvelle classe.
+        Pour chaque attribut de classe héritant de Type, on recrée une nouvelle
+        instance des attributs hérités pour pouvoir maintenir une structure de
+        parentée entre l'attribut de classe et sa nouvelle classe.
 
         L'effet obtenu est que tous les attributs de classe ou des classes parentes
-        de cette classe sont des attributs associés à la classe feuille. Ces attributs
+        de cette classe sont des attributs associés à la classe feuille. Ces attributs
         ont eux-meme un attribut parent qui pointe sur la classe qui les contient.
         """
-        new_cls = type.__new__( mcs, name, bases, classdict )
+        new_cls = type.__new__(mcs, name, bases, classdict)
         new_cls._subtypes = []
         for b in bases:
-            if hasattr(b,'_subtypes'):
+            if hasattr(b, '_subtypes'):
                 new_cls._subtypes += b._subtypes
         # affecte la classe comme parent des attributs de classe
-        # et donne l'occasion aux attributs de se renommer à partir
-        # du nom utilisé.
+        # et donne l'occasion aux attributs de se renommer à partir
+        # du nom utilisé.
         for k, v in classdict.items():
-            if not isinstance( v, BaseType ):
+            if not isinstance(v, BaseType):
                 continue
-            v.reparent( new_cls, k )
-            new_cls._subtypes.append( k )
+            v.reparent(new_cls, k)
+            new_cls._subtypes.append(k)
         return new_cls
 
     def dup_attr(cls, inst):
@@ -85,30 +85,30 @@ class MetaType(type):
         """
         # reinstantiate and reparent subtypes
         for nam in cls._subtypes:
-           obj = getattr( cls, nam )
-           # permet de dupliquer completement l'instance
-           cpy = cPickle.dumps(obj)
-           newobj = cPickle.loads( cpy )
-           newobj.reparent( inst, None )
-           setattr( inst, nam, newobj )
+            obj = getattr(cls, nam)
+            # permet de dupliquer completement l'instance
+            cpy = cPickle.dumps(obj)
+            newobj = cPickle.loads(cpy)
+            newobj.reparent(inst, None)
+            setattr(inst, nam, newobj)
 
     def __call__(cls, *args, **kwargs):
-        """Instanciation d'un Type structuré.
-        Lors de l'instanciation on effectue un travail similaire à la
-        création de classe: Les attributs sont re-parentés à l'instance
-        et réinstanciés pour obtenir une instanciation de toute la structure
+        """Instanciation d'un Type structuré.
+        Lors de l'instanciation on effectue un travail similaire à la
+        création de classe: Les attributs sont re-parentés à l'instance
+        et réinstanciés pour obtenir une instanciation de toute la structure
         et de ses sous-structures.
 
         Les attributs de classe deviennent des attributs d'instance.
         """
         inst = cls.__new__(cls, *args, **kwargs)
         # reinstantiate and reparent subtypes
-        cls.dup_attr( inst )
+        cls.dup_attr(inst)
         type(inst).__init__(inst, *args, **kwargs)
         return inst
 
     def mymethod(cls):
-       pass
+        pass
 
 
 class BaseType(object):
@@ -122,38 +122,36 @@ class BaseType(object):
         self._name = None
         self._parent = None
 
-    def reparent( self, parent, new_name ):
+    def reparent(self, parent, new_name):
         self._parent = parent
         self._name = new_name
         for nam in self._subtypes:
-            obj = getattr( self, nam )
-            obj.reparent( self, nam )
+            obj = getattr(self, nam)
+            obj.reparent(self, nam)
 
     def supprime(self, delete=False):
-        """Permet de casser les boucles de références pour que les ASSD
-        puissent être détruites.
-        Si `delete` vaut True, on supprime l'objet lui-même et pas
-        seulement les références remontantes."""
+        """Permet de casser les boucles de références pour que les ASSD
+        puissent être détruites.
+        Si `delete` vaut True, on supprime l'objet lui-même et pas
+        seulement les références remontantes."""
         self._parent = None
         self._name = None
         for nam in self._subtypes:
             obj = getattr(self, nam)
             obj.supprime(delete)
-        #XXX MC : avec ce code, j'ai l'impression qu'on supprime aussi
-        # des attributs de classe, ce qui pose problème pour une
+        # XXX MC : avec ce code, j'ai l'impression qu'on supprime aussi
+        # des attributs de classe, ce qui pose problème pour une
         # instanciation future...
-        # Dans une version précédente, on utilisait l'attribut
-        # sd_deleted pour ne faire qu'une fois, à voir.
-        # Supprimer les références remontantes devrait suffir.
-        #if delete:
-            #while len(self._subtypes):
-                #nam = self._subtypes.pop(0)
-                #try:
-                    #delattr(self, nam)
-                #except AttributeError:
-                    #pass
-
-    def base( self ):
+        # Supprimer les références remontantes devrait suffir.
+        # if delete:
+            # while len(self._subtypes):
+                # nam = self._subtypes.pop(0)
+                # try:
+                    # delattr(self, nam)
+                # except AttributeError:
+                    # pass
+
+    def base(self):
         if self._parent is None:
             return self
         return self._parent.base()
@@ -161,4 +159,3 @@ class BaseType(object):
 
 class Type(BaseType):
     __metaclass__ = MetaType
-
index 7ba233426577aa09fd7ed2a312fa27813e36849d..7fa6bf39bbce4a4db56bf99275c9c5bdad827c04 100644 (file)
@@ -1,73 +1,83 @@
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2013   EDF R&D
+# coding=utf-8
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2012  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
 #
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
 #
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
 #
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 #
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-_root=None
-_cata=None
-debug=0
+# ======================================================================
+
+_root = None
+_cata = None
+debug = 0
 from Noyau.N_info import message, SUPERV
 
-# Le "current step" est l'étape courante.
-# Une macro se déclare étape courante dans sa méthode Build avant de construire
-# ses étapes filles ou dans BuildExec avant de les exécuter.
-# Les étapes simples le font aussi : dans Execute et BuildExec.
-# (Build ne fait rien pour une étape)
+# Le "current step" est l'étape courante.
+# Une macro se déclare étape courante dans sa méthode Build avant de construire
+# ses étapes filles ou dans BuildExec avant de les exécuter.
+# Les étapes simples le font aussi : dans Execute et BuildExec.
+# (Build ne fait rien pour une étape)
+
 
 def set_current_step(step):
-   """
-      Fonction qui permet de changer la valeur de l'étape courante
-   """
-   global _root
-   if _root : raise Exception("Impossible d'affecter _root. Il devrait valoir None")
-   _root=step
-   #message.debug(SUPERV, "current_step = %s", step and step.nom, stack_id=-1)
+    """
+       Fonction qui permet de changer la valeur de l'étape courante
+    """
+    global _root
+    if _root:
+        raise Exception("Impossible d'affecter _root. Il devrait valoir None")
+    _root = step
+    # message.debug(SUPERV, "current_step = %s", step and step.nom,
+    # stack_id=-1)
+
 
 def get_current_step():
-   """
-      Fonction qui permet d'obtenir la valeur de l'étape courante
-   """
-   return _root
+    """
+       Fonction qui permet d'obtenir la valeur de l'étape courante
+    """
+    return _root
+
 
 def unset_current_step():
-   """
-      Fonction qui permet de remettre à None l'étape courante
-   """
-   global _root
-   _root=None
+    """
+       Fonction qui permet de remettre à None l'étape courante
+    """
+    global _root
+    _root = None
+
 
 def set_current_cata(cata):
-   """
-      Fonction qui permet de changer l'objet catalogue courant
-   """
-   global _cata
-   if _cata : raise Exception("Impossible d'affecter _cata. Il devrait valoir None")
-   _cata=cata
+    """
+       Fonction qui permet de changer l'objet catalogue courant
+    """
+    global _cata
+    if _cata:
+        raise Exception("Impossible d'affecter _cata. Il devrait valoir None")
+    _cata = cata
+
 
 def get_current_cata():
-   """
-      Fonction qui retourne l'objet catalogue courant
-   """
-   return _cata
+    """
+       Fonction qui retourne l'objet catalogue courant
+    """
+    return _cata
 
-def unset_current_cata():
-   """
-      Fonction qui permet de remettre à None le catalogue courant
-   """
-   global _cata
-   _cata=None
 
+def unset_current_cata():
+    """
+       Fonction qui permet de remettre à None le catalogue courant
+    """
+    global _cata
+    _cata = None
index e8bb5e844fa27ce760912f25dd2cbf106f287f38..b65e9fe59db86f385bd7fd8ba72f9756556ca602 100644 (file)
@@ -1,5 +1,4 @@
-# -*- coding: iso-8859-1 -*-
-
+# coding=utf-8
 # Copyright (C) 2007-2013   EDF R&D
 #
 # This library is free software; you can redistribute it and/or
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
 
 
 """
-   Ce module sert à nommer les concepts produits par les commandes.
+   Ce module sert à nommer les concepts produits par les commandes.
    Le nom du concept est obtenu en appelant la fonction GetNomConceptResultat
    du module avec le nom de la commande en argument.
 
    Cette fonction parcourt le source dans lequel la commande se trouve, parse le
-   fichier et retrouve le nom du concept qui se trouve à gauche du signe = précédant
+   fichier et retrouve le nom du concept qui se trouve à gauche du signe = précédant
    le nom de la commande.
 
    Cette fonction utilise la fonction cur_frame du module N_utils qui retourne la frame
-   d'exécution Python située 2 niveaux au-dessus. C'est à partir de cette frame que
-   l'on retrouve le fichier source et le numéro de ligne où se trouve l'appel à la commande.
+   d'exécution Python située 2 niveaux au-dessus. C'est à partir de cette frame que
+   l'on retrouve le fichier source et le numéro de ligne où se trouve l'appel à la commande.
 
 """
 
 # Modules Python
-import re,string
+import re
+import string
 import linecache
 from functools import partial
 
 # Modules EFICAS
 import N_utils
+from strfunc import get_encoding
+
+regex1 = '=?\s*%s\s*\('
+# commentaire standard precede d'un nombre quelconque de blancs (pas
+# multiligne)
+pattern_comment = re.compile(r"^\s*#.*")
 
-regex1='=?\s*%s\s*\('
-#commentaire standard precede d'un nombre quelconque de blancs (pas multiligne)
-pattern_comment   = re.compile(r"^\s*#.*")
 
 def _GetNomConceptResultat(ope, level=2):
-  """
-     Cette fonction recherche dans la pile des appels, l'appel à la commande
-     qui doit etre situé à 2 niveaux au-dessus (cur_frame(2)).
-     On retrouve d'abord la frame d'exécution f. Puis le numéro de la ligne
-     dans le source f.f_lineno et le nom du fichier source (f.f_code.co_filename).
-     A partir de là, on récupère la ligne de source avec linecache.getline
-     et on vérifie que cette ligne correspond véritablement à l'appel.
-
-     En effet, lorsque les commandes tiennent sur plusieurs lignes, on retrouve
-     la dernière ligne. Il faut donc remonter dans le source jusqu'à la première
-     ligne.
-
-     Enfin la fonction evalnom forme un nom acceptable lorsque le concept est un
-     élément d'une liste, par exemple.
-
-  """
-  f=N_utils.cur_frame(level)
-  lineno = f.f_lineno     # XXX Too bad if -O is used
-  #lineno = f_lineno(f)  # Ne marche pas toujours
-  co = f.f_code
-  filename = co.co_filename
-  name = co.co_name
-  #pattern pour identifier le debut de la commande
-  pattern_oper=re.compile(regex1 % ope)
-
-  list=[]
-  while lineno > 0:
-    line = linecache.getline(filename, lineno)
-    lineno=lineno-1
-    if pattern_comment.match(line):continue
-    list.append(line)
-    if pattern_oper.search(line):
-      l=pattern_oper.split(line)
-      list.reverse()
-      # 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)
-      #print "NOMS ",m
-      if m!=[] :  return m[-1]
-      else : return ''
-  #print "appel inconnu"
-  return ""
-
-def evalnom(text,d):
-  """
-   Retourne un nom pour le concept resultat identifie par text
-   Pour obtenir ce nom il y a plusieurs possibilites :
-    1. text est un identificateur python c'est le nom du concept
-    2. text est un element d'une liste on construit le nom en
-      evaluant la partie indice dans le contexte de l'appelant d
-  """
-  l=re.split('([\[\]]+)',text)
-  if l[-1] == '' :l=l[:-1]
-  lll=[]
-  i=0
-  while i<len(l):
-    s=l[i]
-    ll=re.split('[ ,]+',s)
-    if ll[0] == '' :ll=ll[1:]
-    if len(ll) == 1:
-      id0=ll[0]
-    else:
-      lll=lll+ll[0:-1]
-      id0=ll[-1]
-    if i+1<len(l) and l[i+1] == '[': # le nom est suivi d un subscript
-      sub=l[i+2]
-      nom=id0+'_'+str(eval(sub,d))
-      i=i+4
-    else:
-      nom=id0
-      i=i+1
-    lll.append(nom)
-  return lll
+    """
+       Cette fonction recherche dans la pile des appels, l'appel à la commande
+       qui doit etre situé à 2 niveaux au-dessus (cur_frame(2)).
+       On retrouve d'abord la frame d'exécution f. Puis le numéro de la ligne
+       dans le source f.f_lineno et le nom du fichier source (f.f_code.co_filename).
+       A partir de là, on récupère la ligne de source avec linecache.getline
+       et on vérifie que cette ligne correspond véritablement à l'appel.
+
+       En effet, lorsque les commandes tiennent sur plusieurs lignes, on retrouve
+       la dernière ligne. Il faut donc remonter dans le source jusqu'à la première
+       ligne.
+
+       Enfin la fonction evalnom forme un nom acceptable lorsque le concept est un
+       élément d'une liste, par exemple.
+
+    """
+    f = N_utils.cur_frame(level)
+    lineno = f.f_lineno     # XXX Too bad if -O is used
+    # lineno = f_lineno(f)  # Ne marche pas toujours
+    co = f.f_code
+    filename = unicode(co.co_filename, get_encoding())
+    name = co.co_name
+    # pattern pour identifier le debut de la commande
+    pattern_oper = re.compile(regex1 % ope)
+
+    list = []
+    while lineno > 0:
+        line = linecache.getline(filename, lineno)
+        lineno = lineno - 1
+        if pattern_comment.match(line):
+            continue
+        list.append(line)
+        if pattern_oper.search(line):
+            l = pattern_oper.split(line)
+            list.reverse()
+            # 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)
+            # print "NOMS ",m
+            if m != []:
+                return m[-1]
+            else:
+                return ''
+    # print "appel inconnu"
+    return ""
+
+
+def evalnom(text, d):
+    """
+     Retourne un nom pour le concept resultat identifie par text
+     Pour obtenir ce nom il y a plusieurs possibilites :
+      1. text est un identificateur python c'est le nom du concept
+      2. text est un element d'une liste on construit le nom en
+        evaluant la partie indice dans le contexte de l'appelant d
+    """
+    l = re.split('([\[\]]+)', text)
+    if l[-1] == '':
+        l = l[:-1]
+    lll = []
+    i = 0
+    while i < len(l):
+        s = l[i]
+        ll = re.split('[ ,]+', s)
+        if ll[0] == '':
+            ll = ll[1:]
+        if len(ll) == 1:
+            id0 = ll[0]
+        else:
+            lll = lll + ll[0:-1]
+            id0 = ll[-1]
+        if i + 1 < len(l) and l[i + 1] == '[':  # le nom est suivi d un subscript
+            sub = l[i + 2]
+            nom = id0 + '_' + str(eval(sub, d))
+            i = i + 4
+        else:
+            nom = id0
+            i = i + 1
+        lll.append(nom)
+    return lll
+
 
 def f_lineno(f):
-   """
-      Calcule le numero de ligne courant
-      Devrait marcher meme avec -O
-      Semble ne pas marcher en présence de tuples longs
-   """
-   c=f.f_code
-   if not hasattr(c, 'co_lnotab'):return f.f_lineno
-   tab=c.co_lnotab
-   line = c.co_firstlineno
-   stopat = f.f_lasti
-   addr = 0
-   for i in range(0, len(tab), 2):
-       addr = addr + ord(tab[i])
-       if addr > stopat:
-           break
-       line = line + ord(tab[i+1])
-   return line
+    """
+       Calcule le numero de ligne courant
+       Devrait marcher meme avec -O
+       Semble ne pas marcher en présence de tuples longs
+    """
+    c = f.f_code
+    if not hasattr(c, 'co_lnotab'):
+        return f.f_lineno
+    tab = c.co_lnotab
+    line = c.co_firstlineno
+    stopat = f.f_lasti
+    addr = 0
+    for i in range(0, len(tab), 2):
+        addr = addr + ord(tab[i])
+        if addr > stopat:
+            break
+        line = line + ord(tab[i + 1])
+    return line
 
 
 class NamingSystem(N_utils.Singleton):
-    """Cette classe définit un système de nommage dynamique des concepts."""
+
+    """Cette classe définit un système de nommage dynamique des concepts."""
     _singleton_id = 'nommage.NamingSystem'
-    
+
     def __init__(self):
         """Initialisation"""
         self.native = _GetNomConceptResultat
         self.use_global_naming()
 
     def use_naming_function(self, function):
-        """Utilise une fonction particulière de nommage."""
+        """Utilise une fonction particulière de nommage."""
         self.naming_func = function
 
     def use_global_naming(self):
@@ -160,7 +171,7 @@ class NamingSystem(N_utils.Singleton):
         self.naming_func = partial(self.native, level=3)
 
     def __call__(self, *args):
-        """Appel à la fonction de nommage."""
+        """Appel à la fonction de nommage."""
         return self.naming_func(*args)
 
 GetNomConceptResultat = NamingSystem()
index 7bdb345e0d867b84431cc8753d63fbe343ead963..edb7b31ef26d1f3be81022a51007dc953d244d88 100644 (file)
@@ -1,4 +1,4 @@
-# -*- coding: iso-8859-1 -*-
+# coding=utf-8
 # Copyright (C) 2007-2013   EDF R&D
 #
 # This library is free software; you can redistribute it and/or
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
 
+"""Module rassemblant des fonctions utilitaires de manipulations
+de chaines de caractères
 """
-Module rassemblant des fonctions utilitaires de manipulations
-de chaines de caractères
-"""
-# module identique à Execution/strfunc.py pour usage dans Eficas
+# module identique à Execution/strfunc.py pour usage dans Eficas
 
 import locale
 
 _encoding = None
+
+
 def get_encoding():
     """Return local encoding
     """
@@ -63,6 +63,7 @@ def to_unicode(string):
             pass
     return unicode(string, 'utf-8', 'replace')
 
+
 def from_unicode(ustring, encoding, errors='replace'):
     """Try to encode a unicode string using encoding."""
     try:
@@ -71,6 +72,7 @@ def from_unicode(ustring, encoding, errors='replace'):
         pass
     return ustring.encode(encoding, errors)
 
+
 def convert(content, encoding=None, errors='replace'):
     """Convert content using encoding or default encoding if None."""
     if type(content) not in (str, unicode):
@@ -79,6 +81,7 @@ def convert(content, encoding=None, errors='replace'):
         content = to_unicode(content)
     return from_unicode(content, encoding or get_encoding(), errors)
 
+
 def ufmt(uformat, *args):
     """Helper function to format a string by converting all its arguments to unicode"""
     if type(uformat) is not unicode: