Index: trunk/SophyaLib/BaseTools/dvlist.cc
===================================================================
--- trunk/SophyaLib/BaseTools/dvlist.cc	(revision 754)
+++ trunk/SophyaLib/BaseTools/dvlist.cc	(revision 754)
@@ -0,0 +1,450 @@
+//  Classe Dynamic Variable List (DVList) de PEIDA
+//                  R. Ansari  1997
+// LAL (Orsay) / IN2P3-CNRS  DAPNIA/SPP (Saclay) / CEA
+
+#include "machdefs.h"
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "dvlist.h"
+#include "strutil.h"
+
+//++
+// Class	DVList
+// Lib		Outils++
+// include	dvlist.h
+//
+//	Cette classe permet de gérer une ensemble de variables (ou paramètres)
+//	pouvant être définies dynamiquement à l'execution. Le nom des 
+//	variables ne doit pas contenir de blancs ("<espace>") et est 
+//	limité à 64 caractères maximum. Cette classe 
+//	offre la possibilité de sauvegarder l'ensemble 
+//	des variables (Nom, Type, Valeur) dans un fichier, ou de
+//	recréer l'objet DVList et l'ensemble de ses variables à 
+//	partir d'un fichier (Objet PPersist). Une zone commentaire (max=320 c.) 
+//	est associée à chaque objet DVList, accessible à travers  
+//	la méthode "Comment()". Les objets de cette classe sont  
+//	en particulier destinés à être inclus dans d'autres objets 
+//	PPersist plus complexes. La classe DVList gère des 
+//	variables de type entier ("int_8"), réél double précision ("r_8")
+//	et de type chaine de caracteres ("string, char*", maxi 30 caracteres ).
+//	Une classe intermédiaire (*MuTyV*) est utilisée pour représenter une 
+//	variable et fournit les services de conversion entre les différents types.
+//--
+//--
+//++
+// Links	Parents
+// PPersist
+//--
+
+char MuTyV::myStrBuf[64];   // Declare static ds le .h 
+
+static MuTyV ddvdum(-9.e19);
+
+
+//++
+// Titre	Constructeurs
+//--
+
+//++
+// DVList()
+//	Constructeur par défaut
+// DVList(DVList& cfd)
+//	Constructeur par copie. Le nouvel objet est une copie complète de "cfd"
+// DVList(char* flnm)
+//	Constructeur avec initialisation à partir du contenu du fichier (PPF)
+//	"flnm". Le fichier doit avoir été créé par la méthode "Write()"
+//--
+
+/* --Methode-- */
+DVList::DVList()
+{
+comment = "";
+}
+
+/* --Methode-- */
+DVList::DVList(const DVList& dvl)
+{
+Merge(dvl);
+}
+
+/* --Methode-- */
+DVList::DVList(char *flnm)
+{
+PInPersist s(flnm);
+ObjFileIO<DVList> fiodvl(this);
+fiodvl.Read(s);
+}
+
+
+/* --Methode-- */
+DVList::~DVList()
+{
+}
+
+//++
+// Titre	Gestion des variables et opérateurs
+//--
+
+//++
+// void  Clear()
+//	Supprime la définition de toutes les variables de l'objet.
+// DVList&  Merge(const DVList& lv)
+//	Fusionne l'objet avec la liste des variables de l'objet "lv"
+// DVList&  operator= (const DVList& cofr)
+//	Remplace la liste des variables de l'objet par celle de l'objet "cofr".   
+//--
+
+/* --Methode-- */
+DVList&     DVList::operator= (const DVList& dvl)
+{
+Clear();
+return(Merge(dvl));
+}
+
+
+/* --Methode-- */
+void        DVList::Clear()
+{
+mvlist.erase(mvlist.begin(), mvlist.end());
+comment = "";
+}
+
+/* --Methode-- */
+DVList&     DVList::Merge(const DVList& dvl)
+{
+ValList::const_iterator it;
+for(it = dvl.mvlist.begin(); it != dvl.mvlist.end(); it++)
+  {
+  switch ((*it).second.elval.typ) 
+    {
+    case 'I' :
+      SetI((*it).first, (*it).second.elval.mtv.iv);
+      break;
+    case 'D' : 
+      SetD((*it).first, (*it).second.elval.mtv.dv);
+      break;
+    case 'S' : 
+      SetS((*it).first, (*it).second.elval.mtv.strv);
+      break;
+    default :
+      break;
+    }
+  }
+comment = comment + "\n" + dvl.comment;
+return(*this);
+}
+
+
+//++
+// int_8   GetI(string const& key, int_8  def=-1)
+// r_8     GetD(string const& key, r_8 def=-9.e19)
+// string  GetS(string const& key, char* def="")
+//	Retourne la valeur de la variable de nom "key" et de type entier, réél, 
+//	chaine de caracteres.
+//	Si la variable n'existe pas, la valeur par défaut "def" est renvoyée.
+// string  GetComment(string const& key)
+//	Retourne le commentaire associé à la variable de nom "key".
+//--
+
+/* --Methode-- */
+int_8       DVList::GetI(string const& key, int_8 def)
+{
+ValList::iterator it = mvlist.find(key);
+if (it == mvlist.end())  return(def);
+if ( (*it).second.elval.typ != 'I') return(def);
+return((*it).second.elval.mtv.iv);
+}
+
+/* --Methode-- */
+r_8      DVList::GetD(string const& key, r_8 def)
+{
+ValList::iterator it = mvlist.find(key);
+if (it == mvlist.end())  return(def);
+if ( (*it).second.elval.typ != 'D') return(def);
+return((*it).second.elval.mtv.dv);
+}
+
+/* --Methode-- */
+string      DVList::GetS(string const& key, char* def)
+{
+ValList::iterator it = mvlist.find(key);
+if (it == mvlist.end())  return(def);
+if ( (*it).second.elval.typ != 'S') return(def);
+return((*it).second.elval.mtv.strv);
+}
+
+/* --Methode-- */
+string      DVList::GetComment(string const& key)
+{
+ValList::iterator it = mvlist.find(key);
+if (it == mvlist.end())  return("");
+return((*it).second.elcomm);
+}
+
+//++
+// void  SetI(string const& key, int_8  val)
+// void  SetD(string const& key, r_8 val)
+// void  SetS(string const& key, char*  val)
+// void  SetS(string const& key, string val)
+//	Crée la variable de nom "key", de type entier, double, string et 
+//	lui attribue la valeur "val". Si une variable du même nom existe, 
+//	sa valeur et eventuellement son type sont modifiés.  Les noms de
+//	variables ne doivent pas contenir de caractères spéciaux, 
+//	en particulier pas de CR/LF.
+// void  SetComment(string const& key, string const& comm)
+//	Modifie le commentaire associé à la variable de nom "key", si
+//	celle-ci existe. Le texte du commentaire ne doit pas contenir
+//	de caractères spéciaux, et en particulier pas de CR/LF. 
+//--
+
+/* --Methode-- */
+void        DVList::SetI(string const& key, int_8 val)
+{
+Get(key) = (int_8)val;
+}
+
+/* --Methode-- */
+void        DVList::SetD(string const& key, r_8 val)
+{
+Get(key) = (r_8)val;
+}
+
+/* --Methode-- */
+void        DVList::SetS(string const& key, char const* val)
+{
+MuTyV div(val);
+Get(key) = div;
+}
+
+/* --Methode-- */
+void        DVList::SetS(string const& key, string val)
+{
+MuTyV div(val);
+Get(key) = div;
+}
+
+/* --Methode-- */
+void        DVList::SetComment(string const& key, string const& comm)
+{
+ValList::iterator it = mvlist.find(key);
+if (it == mvlist.end())  return;
+(*it).second.elcomm = comm;
+}
+
+//++
+// MuTyV&  Get(string const& key) 
+//	Renvoie une référence sur l'objet "MuTyV" de la liste avec le nom "key".
+//	Si cet objet (variable) n'existe pas, il est créé.
+// MuTyV&     operator()  (string const& key) 
+// MuTyV&     operator[]  (string const& key) 
+//
+//	Renvoie la variable de nom "key". Equivalent à "Get(key)". 
+// string&  Comment()
+//	Renvoie une référence sur le champ commentaire de l'objet.
+//--
+
+/* --Methode-- */
+MuTyV&      DVList::Get(string const& key)
+{
+size_t l = key.length();
+if ( (l < 1) || (key.find_first_of(" ") < l) )  return(ddvdum);
+// dvlElement xxx = {(int_8)0 , ""};  marche pas sur mac/CW (!) - cf DY
+dvlElement xxx; xxx.elval = (int_8)0;  xxx.elcomm = "";
+ValList::iterator it = mvlist.find(key);
+if (it == mvlist.end()) mvlist[key] = xxx;  
+it = mvlist.find(key);
+if (it == mvlist.end()) return(ddvdum); 
+else return((*it).second.elval);
+}
+
+//++
+// Titre	Entrée-Sortie
+//--
+
+//++
+//  void  Print()
+//	Imprime (sur "cout") la liste des variables et leurs valeurs.
+//  void  Print(ostream& os)
+//	Imprime sur le flot "os" la liste des variables et leurs valeurs.
+//  ostream&    operator << (ostream& s, DVList& dvl)
+//	sortie sur flot "s" (Appel a "Print(s)").
+//  void  Write(string const& fn)
+//	Ecriture d'un fichier PPersist de nom "fn"
+//  void  Read(string const& fn)
+//	Lecture d'un fichier PPersist de nom "fn"
+//--
+
+
+/* --Methode-- */
+void        DVList::Print(ostream& os) const
+{
+os << "DVList::Print() - NVar= " << (int)mvlist.size() << "\n";
+if (comment.length() > 0)  os << comment << endl;
+char buff[256];
+ValList::const_iterator it;
+for(it = mvlist.begin(); it != mvlist.end(); it++)  {
+  switch ((*it).second.elval.typ) 
+    {
+    case 'I' :
+      sprintf(buff, "%s = %d (int) %s\n", (*it).first.substr(0,64).c_str(), 
+	      (*it).second.elval.mtv.iv, (*it).second.elcomm.substr(0,128).c_str());
+      break;
+    case 'D' : 
+      sprintf(buff, "%s = %.20g (double) %s\n", (*it).first.substr(0,64).c_str(), 
+	      (*it).second.elval.mtv.dv, (*it).second.elcomm.substr(0,128).c_str());
+      break;
+    case 'S' : 
+      sprintf(buff, "%s = %s (string) %s\n", (*it).first.substr(0,64).c_str(), 
+	      (*it).second.elval.mtv.strv, (*it).second.elcomm.substr(0,128).c_str());
+      break;
+    default :
+      break;
+    }
+  os << (string)buff;
+  }
+os << endl;
+}
+
+
+//++
+// Titre	Exemples
+//	Utilisation des objets *MuTyV* :
+//|	MuTyV mvu;         // Declaration d'une variable 
+//|	mvu = 60;          // mvu est de type entier (= 60)
+//|	mvu = 66.6;        // et double (= 66.6) maintenant ...   
+//|	MuTyV mvi(14);     // On construit une variable entiere = 14
+//|	r_4 x = mvi;     // x vaut 14.0
+//|	MuTyV mvd(44.4);   // Variable double = 44.4
+//|	int k = mvd;       // k vaut 44  
+//|	MuTyV mvs("Bonjour, Ca va ?");   // Variable chaine de caracteres 
+//|	string s = mvs;    // s vaut "Bonjour, Ca va ?"  
+//	Utilisation des *DVList* :		 
+//|	DVList  dvl;
+//|	dvl("toto") = 14;
+//|	dvl("titi") = 25.5;
+//|	dvl("tata") = "Bonjour, Ca va ?";
+//	Majuscules et minuscules sont differenciees pour les noms, pas de blanc ...
+//|	dvl("hello") = 88;
+//|	dvl("Hello") = 77.77;
+//|	dvl.Comment() = "Test d'objet DVList, avec variables hello, Hello ";
+//|	dvl.Write("dvlist.ppf");
+//	Plus loin, ou dans un autre programme, on relit le fichier fabrique plus haut 
+//|	DVList dvlr("dvlist.ppf");
+//|	int k = dvlr["toto"] ;     //  k = 14
+//|	r_8 b = dvlr["titi"] ;  //  b = 25.5
+//|	string s =  dvlr["tata"] ; //  s = "Bonjour, Ca va ?"
+//|	r_4 c = dvlr["Hello"] ;  //  c = 77.77
+//|	int l =  dvlr["Hello"] ;   //  l = 77
+//|	int m =  dvlr["hello"] ;   //  m = 88
+//--
+
+
+//----------------------------------------------------------
+// Classe pour la gestion de persistance
+// ObjFileIO<DVList>
+//----------------------------------------------------------
+
+/* --Methode-- */
+void        ObjFileIO<DVList>::WriteSelf(POutPersist& s) const
+{
+char buf[512];
+
+int lc = dobj->Comment().length();
+if (lc > 511) lc = 511;
+if (lc > 0) {
+  sprintf(buf,"Comment: ( %6d ) ", lc); 
+  s.PutLine(buf);
+  s.PutBytes(dobj->Comment().c_str(), lc);
+  }
+s.PutLine("----Variable-List---------------");
+DVList::ValList::const_iterator it;
+for(it = dobj->Begin(); it != dobj->End(); it++)  {
+  switch ((*it).second.elval.typ) {
+    case 'I' :
+      sprintf(buf,"I %s %d", (*it).first.substr(0,64).c_str(), (*it).second.elval.mtv.iv );
+      s.PutLine(buf); 
+      break;
+    case 'D' : 
+      sprintf(buf,"D %s %.20g", (*it).first.substr(0,64).c_str(), (*it).second.elval.mtv.dv );
+      s.PutLine(buf); 
+      break;
+    case 'S' : 
+      sprintf(buf,"S %s %s", (*it).first.substr(0,64).c_str(), (*it).second.elval.mtv.strv );
+      s.PutLine(buf); 
+      break;
+    default :
+      break;
+  }
+// Ecriture eventuelle du commentaire associe
+  if ((*it).second.elcomm.length() > 0) {
+    sprintf(buf,"# %s", (*it).second.elcomm.substr(0,256).c_str());
+    s.PutLine(buf); 
+  }
+}
+
+s.PutLine("ZZZZZ--End-of-Varible-List------");
+}
+
+/* --Methode-- */
+void        ObjFileIO<DVList>::ReadSelf(PInPersist& s)
+{
+char buf[512];
+int_8 j,iv;
+r_8 dv;
+bool ok=true;
+buf[0] = '\0';
+dobj->Clear();
+
+s.GetLine(buf, 511);  // Pour lire les "------- "
+if (buf[0] != '-') {  // Il y a un champ commentaire a lire 
+  buf[18] ='\0';
+  int lc = atoi(buf+11);
+  if (lc > 511)  { 
+    cerr << "DVList::ReadSelf() Pb/Bug ??  CommentLength= " << lc << endl;
+    lc = 511;
+    }
+  s.GetBytes(buf, lc);
+  buf[lc] ='\0';
+  dobj->Comment() = buf;
+  }
+
+string key="";
+while(ok) {
+  s.GetLine(buf, 511);
+  buf[511] = '\0';
+  if (strncmp(buf,"ZZZZZ",5) == 0)  { ok=false; break; }
+  if (buf[0] == '#') {
+    dobj->SetComment(key, buf+2);
+    continue;
+  }
+  j = posc(buf+2, ' ')+2;
+  buf[j] = '\0';
+  switch (buf[0]) {
+    case 'I' :
+      iv = (int_8)atol(buf+j+1);
+      key = buf+2;
+      dobj->SetI(key, iv);
+      break;
+    case 'D' :
+      dv = atof(buf+j+1);
+      key = buf+2;
+      dobj->SetD(key, dv);
+      break;
+    case 'S' :
+      key = buf+2;
+      dobj->SetS(key, buf+j+1);
+      break;
+    default :
+      break;
+    }
+  } 
+}
+
+#ifdef __CXX_PRAGMA_TEMPLATES__
+#pragma define_template ObjFileIO<DVList>
+#endif
+
+#if defined(ANSI_TEMPLATES) || defined(GNU_TEMPLATES)
+template class ObjFileIO<DVList>;
+#endif
Index: trunk/SophyaLib/BaseTools/dvlist.h
===================================================================
--- trunk/SophyaLib/BaseTools/dvlist.h	(revision 754)
+++ trunk/SophyaLib/BaseTools/dvlist.h	(revision 754)
@@ -0,0 +1,136 @@
+// This may look like C code, but it is really -*- C++ -*-
+// Classe DVList : Liste dynamique de variables (valeurs) 
+// identifiees par un nom    Reza Ansari - Dec 96
+
+#ifndef DVLIST_H_SEEN
+#define DVLIST_H_SEEN
+
+#include "objfio.h"
+
+#include <stdio.h>
+
+#include <iostream.h>
+
+#include <list>
+#include <map>
+#include <string.h>
+#include <string>
+
+namespace SOPHYA {
+
+// Classe utilitaire pour manipuler des variables typees 
+class MuTyV {
+public:
+  union {
+  int_8 iv;
+  r_8 dv;
+  char strv[31];
+  } mtv; 
+  char typ;
+
+  static char myStrBuf[64];  
+
+  inline MuTyV() { typ = 'I'; mtv.iv = 0;  mtv.dv = 0.;  mtv.strv[0] ='\0'; }
+  inline MuTyV(int_4 i) { typ = 'I'; mtv.iv = (int_8)i; mtv.dv = 0.;  mtv.strv[0] ='\0'; }
+  inline MuTyV(int_8 i) { typ = 'I'; mtv.iv = i; mtv.dv = 0.;  mtv.strv[0] ='\0'; }
+  inline MuTyV(r_4 f) { typ = 'D'; mtv.dv = (r_8)f;  mtv.iv = 0;  mtv.strv[0] ='\0'; }
+  inline MuTyV(r_8 d) { typ = 'D'; mtv.dv = d; mtv.iv = 0;  mtv.strv[0] ='\0'; }
+  inline MuTyV(char const* s)  { typ = 'S'; strncpy(mtv.strv, s, 31); mtv.strv[30] = '\0'; }
+  inline MuTyV(string const& s) { typ = 'S'; strncpy(mtv.strv, s.c_str(), 31); mtv.strv[30] = '\0'; }
+  inline int_4  operator= (int_4 v)  { typ = 'I'; mtv.iv = (int_8)v; return(v); }
+  inline int_8  operator= (int_8 v)  { typ = 'I'; mtv.iv = v; return(v); }
+  inline r_4  operator= (r_4 v)  { typ = 'D'; mtv.dv = (r_8)v; return(v); }
+  inline r_8 operator= (r_8 v) { typ = 'D'; mtv.dv = v; return(v); }
+  inline char*  operator= (char* s)  { typ = 'S'; strncpy(mtv.strv, s, 31); 
+                                       mtv.strv[30] = '\0';  return(s); }
+  inline string& operator= (string& s)    { typ = 'S'; strncpy(mtv.strv, s.c_str(), 31); 
+                                            mtv.strv[30] = '\0'; return(s); }
+
+  inline operator int_4() { if (typ == 'I')  return((int_4)mtv.iv);
+                            else if (typ == 'D') return((int_4)mtv.dv); 
+                            else return(atol(mtv.strv)); }
+  inline operator int_8() { if (typ == 'I')  return((int_8)mtv.iv);
+                            else if (typ == 'D') return((int_8)mtv.dv); 
+                            else return(atol(mtv.strv)); }
+  inline operator r_4() { if (typ == 'I')  return((r_4)mtv.iv);
+                            else if (typ == 'D') return((r_4)mtv.dv); 
+                            else return((r_4)atof(mtv.strv)); }
+  inline operator r_8() { if (typ == 'I')  return((r_8)mtv.iv);
+                            else if (typ == 'D') return(mtv.dv); 
+                            else return(atof(mtv.strv)); }
+  inline operator string() { char *ss=myStrBuf;
+                            if (typ == 'I')  sprintf(ss,"%ld", mtv.iv);
+                            else if (typ == 'D') sprintf(ss,"%.20g", mtv.dv);
+                            else ss = mtv.strv;
+                            return(ss); }
+};
+
+//  Classe liste de variables  Dynamic Variable List  
+
+class DVList : public AnyDataObj {
+public:
+//  enum {classId = ClassId_DVList };
+
+                    DVList();
+                    DVList(const DVList&);
+                    DVList(char *flnm);
+
+  virtual           ~DVList();
+
+  DVList&           operator= (const DVList&);
+
+  void              Clear();
+  DVList&           Merge(const DVList&);
+
+  int_8             GetI(string const& key, int_8 def=-1);
+  r_8               GetD(string const& key, r_8 def=-9.e19);
+  string            GetS(string const& key, char* def="");
+  string            GetComment(string const& key);
+
+  void              SetI(string const& key, int_8 val);
+  void              SetD(string const& key, r_8 val);
+  void              SetS(string const& key, char const*  val);
+  void              SetS(string const& key, string val);
+  void              SetComment(string const& key, string const& comm);
+
+  MuTyV&            Get(string const& key);
+  inline MuTyV&     operator()  (string const& key)  { return Get(key); }
+  inline MuTyV&     operator[]  (string const& key)  { return Get(key); }
+  inline string&    Comment() { return(comment); }
+
+  inline void       Print() const  { Print(cout); }  
+  virtual void      Print(ostream& os)  const;
+
+// Chaque element dans un DVList est constitue desormais d'un MuTyV
+// et d'une chaine de caracteres (commentaire) regroupe dans la structure
+// dvlElement. Ces elements sont associes aux noms de variables dans un 
+// map<...> ValList.            Reza 02/2000
+
+  struct dvlElement {MuTyV elval; string elcomm; } ;
+  typedef map<string, dvlElement, less<string> >  ValList; 
+  inline ValList::const_iterator Begin() { return(mvlist.begin()); } 
+  inline ValList::const_iterator End() { return(mvlist.end()); } 
+  
+
+private:
+  
+  ValList mvlist;
+  string comment;
+};
+
+inline ostream& operator << (ostream& s, DVList const & dvl)
+  {  dvl.Print(s);  return(s);  }
+
+inline POutPersist& operator << (POutPersist& os, DVList & obj)
+{ ObjFileIO<DVList> fio(&obj);  fio.Write(os);  return(os); }
+inline PInPersist& operator >> (PInPersist& is, DVList & obj)
+{ ObjFileIO<DVList> fio(&obj);  fio.Read(is);  return(is); }
+
+// Classe pour la gestion de persistance
+// ObjFileIO<DVList>
+
+} // namespace SOPHYA
+
+#endif /* DVLIST_H__SEEN */
+
+
Index: trunk/SophyaLib/BaseTools/ndatablock.cc
===================================================================
--- trunk/SophyaLib/BaseTools/ndatablock.cc	(revision 753)
+++ trunk/SophyaLib/BaseTools/ndatablock.cc	(revision 754)
@@ -669,4 +669,12 @@
 }
 
+template <class T>
+void FIO_NDataBlock<T>::SetDataObj(AnyDataObj & o)
+{
+NDataBlock<T> * po = dynamic_cast< NDataBlock<T> * >(&o);
+if (po == NULL) return;
+if (ownobj && dobj) delete dobj;
+dobj = po; ownobj = false;
+} 
 
 template <class T>
Index: trunk/SophyaLib/BaseTools/ndatablock.h
===================================================================
--- trunk/SophyaLib/BaseTools/ndatablock.h	(revision 753)
+++ trunk/SophyaLib/BaseTools/ndatablock.h	(revision 754)
@@ -170,4 +170,5 @@
   virtual ~FIO_NDataBlock();
   virtual AnyDataObj* DataObj();
+  virtual void        SetDataObj(AnyDataObj & o);
   inline operator NDataBlock<T>() { return(*dobj); }
 protected :
Index: trunk/SophyaLib/BaseTools/objfio.h
===================================================================
--- trunk/SophyaLib/BaseTools/objfio.h	(revision 753)
+++ trunk/SophyaLib/BaseTools/objfio.h	(revision 754)
@@ -26,4 +26,8 @@
 
   virtual   AnyDataObj* DataObj() { return(dobj); }
+  virtual   void        SetDataObj(AnyDataObj & o) 
+          {  T * po = dynamic_cast< T * >(& o); if (po == NULL) return;
+	  if (ownobj && dobj) delete dobj;  dobj = po; ownobj = false; }    
+
   inline operator T() { return(*dobj); }
 
Index: trunk/SophyaLib/BaseTools/peidainit.cc
===================================================================
--- trunk/SophyaLib/BaseTools/peidainit.cc	(revision 753)
+++ 	(revision )
@@ -1,100 +1,0 @@
-#include "machdefs.h"
-#include <stdlib.h>
-#include <stdio.h>
-#include <complex>
-#include "pexceptions.h"
-#include "ppersist.h"
-#include "peidainit.h"
-#include "ndatablock.h"
-#include "sversion.h"
-
-// ---  Classe d'initialisation de PEIDA++, (PPersistMgr en particulier)
-int PeidaInitiator::FgInit = 0;
-
-PeidaInitiator::PeidaInitiator()
-{
-  FgInit++;
-  if (FgInit > 1)  return;
-
-  InitFailNewHandler();
-
-  #ifdef xx__mac__
-  //InitToolBox();
-  //SIOUXSettings.initializeTB = FALSE;
-  SIOUXSettings.autocloseonquit = FALSE;
-  SIOUXSettings.asktosaveonclose = FALSE;
-  SIOUXSettings.showstatusline = TRUE;
-  #endif
-
-  PIOPersist::Initialize();
-  PPRegister(FIO_NDataBlock<uint_1>);
-  PPRegister(FIO_NDataBlock<uint_2>);
-  PPRegister(FIO_NDataBlock<int_2>);
-  PPRegister(FIO_NDataBlock<int_4>);
-  PPRegister(FIO_NDataBlock<int_8>);
-  PPRegister(FIO_NDataBlock<uint_4>);
-  PPRegister(FIO_NDataBlock<uint_8>);
-  PPRegister(FIO_NDataBlock<r_4>);
-  PPRegister(FIO_NDataBlock<r_8>);
-  PPRegister(FIO_NDataBlock< complex<float> >);
-  PPRegister(FIO_NDataBlock< complex<double> >);
-
-//DEL  PPersistMgr::classList = new PPersistMgr::ClassList;
-//DEL  PShPersist::objList    = new PShPersist::ObjList;
-  
-
-#if (!defined(__GNUG__) && !defined(__MWERKS__) && !defined(HPUX))
-  // pas de bufferisation pour printf   cmv 18/3/97 selon E.A.
-  // setvbuf(stdout,NULL,_IOLBF,0); setvbuf(stderr,NULL,_IOLBF,0);
-  setlinebuf(stdout);
-  setlinebuf(stderr);
-#endif
-
-  // si var env PEIDA_NOPRTVER definie pas de print
-  if(!getenv("SOPHYA_NOPRTVER")) Version(true);
-}
-
-PeidaInitiator::~PeidaInitiator()
-{
-  FgInit--;
-/*
-  if (FgInit == 0)
-    {
-    delete PPersistMgr::classList; PPersistMgr::classList = NULL;
-    delete PShPersist::objList;    PShPersist::objList = NULL;
-    }
-    */
-}
-
-double PeidaInitiator::Version(bool fgprt)
-{
-if (fgprt) {
-  char* compiler = 0;
-  #ifdef __GNUG__
-  compiler = "gcc " __VERSION__;
-  #endif
-  #ifdef __DECCXX
-  compiler = "cxx " ;
-  #endif
-  #ifdef __aCC__
-  compiler = const_cast<char *>("HP-aCC ") ;
-  #endif
-  #ifdef __KCC__
-  compiler = const_cast<char *>("KCC ") ;
-  #endif
-  #ifdef __SGICC__
-  compiler = const_cast<char *>("SGI-CC ") ;
-  #endif
-  #ifdef __MWERKS__
-  compiler = const_cast<char *>("Codewarrior ");
-  #endif
-  fprintf(stderr,"SOPHYA Version %4.1f Revision %d (%s) -- %s %s %s\n",
-          SOPHYA_VERSION, SOPHYA_REVISION, SOPHYA_TAG,
-          __DATE__, __TIME__, compiler);
-}
-return(SOPHYA_VERSION + (SOPHYA_REVISION/1000.));
-}
- 
-// On met un objet initiator en statique, pour les loaders qui savent 
-// appeler le constructeur des objets statiques   Reza 08/98
-static PeidaInitiator ppeidainit;
Index: trunk/SophyaLib/BaseTools/peidainit.h
===================================================================
--- trunk/SophyaLib/BaseTools/peidainit.h	(revision 753)
+++ 	(revision )
@@ -1,26 +1,0 @@
-// This may look like C code, but it is really -*- C++ -*-
-// Classe d'initialiseur de module de PEIDA 
-
-#ifndef PEIDAINIT_H_SEEN
-#define PEIDAINIT_H_SEEN
-
-#include "machdefs.h"
-
-void PrintPeidaVersion(void);
-double PeidaVersion(void); /* Version + (Revision/1000) */
-
-// Classe d''initialisation pour les modules de PEIDA++
-
-class PeidaInitiator {
-private:
-  static int FgInit;
-public:
-  			PeidaInitiator();
-  virtual		~PeidaInitiator();
-  virtual double 	Version(bool fgprt=true);
-};
-
-#define PeidaInit() PeidaInitiator peidainitiator
-
-#endif
-
Index: trunk/SophyaLib/BaseTools/ppersist.cc
===================================================================
--- trunk/SophyaLib/BaseTools/ppersist.cc	(revision 753)
+++ trunk/SophyaLib/BaseTools/ppersist.cc	(revision 754)
@@ -4,5 +4,4 @@
 #include <time.h>
 #include "pexceptions.h"
-#include "peidainit.h"
 #include "ppersist.h"
 #include <fstream.h>
Index: trunk/SophyaLib/BaseTools/ppersist.h
===================================================================
--- trunk/SophyaLib/BaseTools/ppersist.h	(revision 753)
+++ trunk/SophyaLib/BaseTools/ppersist.h	(revision 754)
@@ -50,6 +50,7 @@
     void               ReadAtTag(PInPersist& s, string const& tag);
 
-    virtual AnyDataObj* DataObj()       // Retourne l'objet reel $CHECK$ - Reza 
-                  { return(NULL); }     // Devrait etre virtuelle pure
+    virtual AnyDataObj* DataObj()=0;       // Retourne l'objet reel 
+    virtual void       SetDataObj(AnyDataObj &)=0;       
+
   protected:  
     virtual void       ReadSelf(PInPersist&)=0;           
@@ -332,5 +333,5 @@
   
 #define PPRegister(className) PPersistRegistrar<className>::Register(#className);
-  
+
 } // namespace
 
Index: trunk/SophyaLib/BaseTools/smathconst.h
===================================================================
--- trunk/SophyaLib/BaseTools/smathconst.h	(revision 754)
+++ trunk/SophyaLib/BaseTools/smathconst.h	(revision 754)
@@ -0,0 +1,48 @@
+/* quelques  constantes mathematiques utiles */
+#ifndef SMATHCONST_H_SEEN
+#define SMATHCONST_H_SEEN
+
+#include "machdefs.h"
+
+/* EA conflit entre les diverses copies de nbmath.h, nbconst.h... A nettoyer... */
+#undef  Pi   
+#undef  Pis2
+#undef  DeuxPi 
+#undef  SPi   
+#undef  S2Pi   
+#undef  Rac2   
+#undef  Log2   
+#undef  LnPi   
+#undef  LgPi   
+#undef  Ln10   
+#undef  DftoDm 
+#undef  Hln2pi 
+#undef  JourSec 
+#undef  AnSec  
+
+#undef  GRAND  
+#undef  GRAND2 
+#undef  IGRAND 
+
+#define  Pi     (double) ( 3.14159265358979310e+00)  /* c'est Pi */
+#define  Pis2   (double) (1.57079632679489655)       /* c'est Pi/2 */
+#define  DeuxPi (double) ( 6.28318530717958620e+00)  /* c'est 2*Pi */
+#define  SPi    (double) ( 1.77245385090551590e+00)  /* c'est sqrt(Pi) */
+#define  S2Pi   (double) ( 2.50662827463100020e+00)  /* c'est sqrt(2*Pi) */
+#define  Rac2   (double) ( 1.41421356237309510e+00)  /* c'est sqrt(2) */
+#define  Log2   (double) ( 3.01029995663981200e-01)  /* c'est log10(2) */
+#define  LnPi   (double) ( 1.14472988584940020e+00)  /* c'est ln(Pi) */
+#define  LgPi   (double) ( 4.97149872694133850e-01)  /* c'est log10(Pi) */
+#define  Ln10   (double) ( 2.30258509299404590e+00)  /* c'est ln(10) */
+#define  DftoDm (double) ( 1.08573620475812940e+00)  /* c'est 2.5/ln(10) */
+#define  Hln2pi (double) ( 9.18938533204672670e-01)  /* c'est Ln(2*pi)/2 */
+
+#define  JourSec (float) (86400.000000) /* nombre de secondes dans 24H */
+#define  AnSec  (int) (31557600) /* nombre de secondes dans 365.25 jours */
+
+#define  GRAND  (float)  (1.e+35)
+#define  GRAND2 (double) (1.e+35)
+#define  IGRAND (int_4) (2147483647)
+
+
+#endif
Index: trunk/SophyaLib/BaseTools/sophyainit.cc
===================================================================
--- trunk/SophyaLib/BaseTools/sophyainit.cc	(revision 754)
+++ trunk/SophyaLib/BaseTools/sophyainit.cc	(revision 754)
@@ -0,0 +1,113 @@
+#include "machdefs.h"
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <complex>
+
+#include "sophyainit.h"
+
+#include "pexceptions.h"
+
+#include "ppersist.h"
+#include "ndatablock.h"
+#include "dvlist.h"
+
+#include "sversion.h"
+
+// ---  Classe d'initialisation de SOPHYA, (PPersistMgr en particulier)
+int SophyaInitiator::FgInit = 0;
+
+SophyaInitiator::SophyaInitiator()
+{
+  FgInit++;
+  if (FgInit > 1)  return;
+
+  InitFailNewHandler();
+
+  #ifdef xx__mac__
+  //InitToolBox();
+  //SIOUXSettings.initializeTB = FALSE;
+  SIOUXSettings.autocloseonquit = FALSE;
+  SIOUXSettings.asktosaveonclose = FALSE;
+  SIOUXSettings.showstatusline = TRUE;
+  #endif
+
+  PIOPersist::Initialize();
+  PPRegister(FIO_NDataBlock<uint_1>);
+  PPRegister(FIO_NDataBlock<uint_2>);
+  PPRegister(FIO_NDataBlock<int_2>);
+  PPRegister(FIO_NDataBlock<int_4>);
+  PPRegister(FIO_NDataBlock<int_8>);
+  PPRegister(FIO_NDataBlock<uint_4>);
+  PPRegister(FIO_NDataBlock<uint_8>);
+  PPRegister(FIO_NDataBlock<r_4>);
+  PPRegister(FIO_NDataBlock<r_8>);
+  PPRegister(FIO_NDataBlock< complex<float> >);
+  PPRegister(FIO_NDataBlock< complex<double> >);
+
+  PPRegister(ObjFileIO<DVList>);
+
+
+#if (!defined(__GNUG__) && !defined(__MWERKS__) && !defined(HPUX))
+  // pas de bufferisation pour printf   cmv 18/3/97 selon E.A.
+  // setvbuf(stdout,NULL,_IOLBF,0); setvbuf(stderr,NULL,_IOLBF,0);
+  setlinebuf(stdout);
+  setlinebuf(stderr);
+#endif
+
+  // si var env SOPHYA_NOPRTVER definie pas de print
+  if(!getenv("SOPHYA_NOPRTVER")) Version(true);
+
+  int pnice;
+  char* snice = getenv("SOPHYA_NICE");
+  if (!snice) pnice=8;
+  else pnice = atoi(snice);
+  nice(pnice);
+
+}
+
+SophyaInitiator::~SophyaInitiator()
+{
+  FgInit--;
+/*
+  if (FgInit == 0)
+    {
+    delete PPersistMgr::classList; PPersistMgr::classList = NULL;
+    delete PShPersist::objList;    PShPersist::objList = NULL;
+    }
+    */
+}
+
+double SophyaInitiator::Version(bool fgprt)
+{
+if (fgprt) {
+  char* compiler = 0;
+  #ifdef __GNUG__
+  compiler = "gcc " __VERSION__;
+  #endif
+  #ifdef __DECCXX
+  compiler = "cxx " ;
+  #endif
+  #ifdef __aCC__
+  compiler = const_cast<char *>("HP-aCC ") ;
+  #endif
+  #ifdef __KCC__
+  compiler = const_cast<char *>("KCC ") ;
+  #endif
+  #ifdef __SGICC__
+  compiler = const_cast<char *>("SGI-CC ") ;
+  #endif
+  #ifdef __MWERKS__
+  compiler = const_cast<char *>("Codewarrior ");
+  #endif
+  fprintf(stderr,"SOPHYA Version %4.1f Revision %d (%s) -- %s %s %s\n",
+          SOPHYA_VERSION, SOPHYA_REVISION, SOPHYA_TAG,
+          __DATE__, __TIME__, compiler);
+}
+return(SOPHYA_VERSION + (SOPHYA_REVISION/1000.));
+}
+ 
+// On met un objet initiator en statique, pour les loaders qui savent 
+// appeler le constructeur des objets statiques   Reza 08/98
+static SophyaInitiator psophyainit;
Index: trunk/SophyaLib/BaseTools/sophyainit.h
===================================================================
--- trunk/SophyaLib/BaseTools/sophyainit.h	(revision 754)
+++ trunk/SophyaLib/BaseTools/sophyainit.h	(revision 754)
@@ -0,0 +1,30 @@
+// This may look like C code, but it is really -*- C++ -*-
+// Classe d'initialiseur de module de SOPHYA
+
+#ifndef SOPHYAINIT_H_SEEN
+#define SOPHYAINIT_H_SEEN
+
+#include "machdefs.h"
+
+namespace SOPHYA {
+
+void PrintSophyaVersion(void);
+double SophyaVersion(void); /* Version + (Revision/1000) */
+
+// Classe d''initialisation pour les modules de PEIDA++
+
+class SophyaInitiator {
+private:
+  static int FgInit;
+public:
+  			SophyaInitiator();
+  virtual		~SophyaInitiator();
+  virtual double 	Version(bool fgprt=true);
+};
+
+#define SophyaInit() SophyaInitiator sophyainitiator
+
+} // Fin du namespace
+
+#endif
+
Index: trunk/SophyaLib/BaseTools/sversion.h
===================================================================
--- trunk/SophyaLib/BaseTools/sversion.h	(revision 753)
+++ trunk/SophyaLib/BaseTools/sversion.h	(revision 754)
@@ -2,7 +2,7 @@
 #define SVERSION_H
 
-#define SOPHYA_VERSION   0.8 
-#define SOPHYA_REVISION  13
-#define SOPHYA_TAG       "V_Fev2000"
+#define SOPHYA_VERSION   0.9 
+#define SOPHYA_REVISION  1
+#define SOPHYA_TAG       "V_Mar2000"
 
 #endif
Index: trunk/SophyaLib/SUtils/datacards.cc
===================================================================
--- trunk/SophyaLib/SUtils/datacards.cc	(revision 754)
+++ trunk/SophyaLib/SUtils/datacards.cc	(revision 754)
@@ -0,0 +1,312 @@
+// $Id: datacards.cc,v 1.1 2000-03-02 16:10:58 ansari Exp $
+//
+// Datacards, acquisition EROS II
+//
+//
+// Eric Aubourg, Decembre 95
+//
+// DAPNIA/SPP (Saclay) / CEA
+
+#include "machdefs.h"
+#include "datacards.h"
+#include "pexceptions.h"
+#include <algorithm>
+#include <iostream.h>
+#include <iomanip.h>
+#include <stdio.h>
+
+//++
+// Class	DataCards
+// Lib		Outils++ 
+// include	datacards.h
+//
+//   	Cette classe permet la gestion des parametres d'un programme a partir 
+//   	de mot-cle (lecture d'un fichier par exemple)
+//--
+
+//++
+// Titre	Constructeurs
+//--
+//++
+//
+// DataCards()
+// DataCards(string const& fn)
+//    Createur avec lecture des parametres ds le fichier de nom "fn"
+//--
+
+DataCards::DataCards()
+{
+}
+
+DataCards::DataCards(string const& fn)
+{
+  ReadFile(fn);
+}
+
+//++
+// Titre	Methodes
+//--
+//++
+// AddProcF(ProcCard f, string const& mtch="*")
+//	Ajoute une fonction de traitement a la liste pour les mots cle
+//      compatibles avec la chaine "mtch" ("mtch" peut contenir "*" en debut 
+//      fin de mot) 
+//
+// Clear()
+//	Supprime les cartes existantes
+//
+// ReadFile(string const& fn) 
+//      Lit le contenu du fichiers "fn" et ajoute les cartes a la liste
+//
+// AppendCard(string const& line)
+//	Rajoute la carte "line" a la liste
+//--
+
+void
+DataCards::AddProcF(ProcCard f, string const& mtch)
+{
+CrdPF mpf;
+if (f == NULL)  return;
+mpf.pf = f;
+if (mtch.length() <= 0)  mpf.patt = "*";
+else  mpf.patt = mtch;
+cpfs.push_back(mpf);
+
+// On applique cette nouvelle fonction aux cartes existantes
+CardList::iterator  ic;
+for(ic = cards.begin(); ic != cards.end(); ic ++)
+  {
+  vector<string>::iterator ik;
+  string tks;
+  for(ik = (*ic).tokens.begin(); ik != (*ic).tokens.end(); ik++)
+    tks = tks + " " + (*ik);
+  ApplyPF(mpf, (*ic).kw, tks);
+  }
+}
+
+void
+DataCards::Clear()
+{
+cards.erase(cards.begin(), cards.end());
+}
+
+void
+DataCards::ReadFile(string const& fn)
+{
+  string file = fn;
+  if (file == "") {
+    char * efn = getenv("PEIDA_DATACARDS");
+    if (efn != NULL)    file = efn;  
+  }
+  if (file == "")  return;
+
+  try {
+    DoReadFile(file);
+  } catch(...) {
+    char* wdp = getenv("PEIDA_WORK");
+    if (wdp) {
+      cerr << "DataCards::ReadFile() Error reading file " << fn << " (Trying with PEIDA_WORK) \n";
+      file = wdp + file;
+      DoReadFile(file);
+    }
+    else cerr << "DataCards::ReadFile() Error reading file " << fn << "\n";
+    throw IOExc("DataCards::ReadFile() Error");  
+  } 
+}
+
+void
+DataCards::AppendCard(string const& crd)
+{
+Card c;
+size_t p = 1;
+size_t q = crd.find_first_of(" \t");
+size_t l = crd.length();
+
+string toks;
+if (l < 2)  return;
+if (crd[0] != '@')  return;
+
+if (q < l)
+  {  c.kw = crd.substr(p,q-p);  toks = crd.substr(q, l-q); }
+else { c.kw = crd.substr(p,l-p);  toks = ""; }
+//  On applique les ProcFunc's
+ApplyPFL(c.kw, toks);
+while (q < l) 
+  {
+  p = crd.find_first_not_of(" \t",q+1); // au debut d'un token
+  if (p>=l) break;
+  q = crd.find_first_of(" \t",p); // la fin du token;
+  string token = crd.substr(p,q-p);
+  c.tokens.push_back(token);
+  }
+// On supprime la carte de la liste, si elle existe deja ...
+RemoveCard(c.kw);
+cards.push_back(c);
+}
+
+void
+DataCards::DoReadFile(string const& fn)
+{
+char line_buff[512];
+FILE *fip;
+
+if ( (fip = fopen(fn.c_str(),"r")) == NULL )  
+  throw IOExc("DataCards::DoReadFile() fopen Error ") ;
+while (fgets(line_buff,511,fip) != NULL)
+  {
+  line_buff[strlen(line_buff)-1] = '\0';   /*  LF/CR de la fin */
+  string line(line_buff);
+  AppendCard(line);
+  }
+}
+
+int
+DataCards::ApplyPF(CrdPF & cpf, string const& key, string const& toks)
+{
+int l,lk;
+int rc = 0;
+// On verifie si le "pattern" correspond
+bool mtch = false;
+l = cpf.patt.length(); 
+if (cpf.patt == "*")  mtch = true;
+else if (cpf.patt[0] == '*')   
+  {
+  lk = key.length();
+  if (cpf.patt[l-1] != '*')
+    {
+    if (strcmp(key.c_str()+(lk-l+1), cpf.patt.c_str()+1) == 0)   mtch = true;
+    }
+  else if  (key.find(cpf.patt.substr(1,l-2)) < lk)  mtch = true;
+  }
+else if (cpf.patt[l-1] == '*')
+  {
+  if ( strncmp(key.c_str(), cpf.patt.c_str(),l-1) == 0)  mtch = true;
+  }
+else if (key == cpf.patt)  mtch = true;
+
+// Si oui, on appelle la fonction correspondante
+if (mtch)  rc = cpf.pf(key, toks); 
+
+return(rc);
+}
+
+
+int
+DataCards::ApplyPFL(string const& key, string const& toks)
+{
+int rc = 0;
+CrdPFList::iterator icf;
+for(icf = cpfs.begin(); icf != cpfs.end(); icf++)
+  rc += ApplyPF((*icf), key, toks);
+return(rc);
+}
+
+void  
+DataCards::RemoveCard(string const& key)
+{
+CardList::iterator i;
+for(i=cards.begin(); i != cards.end(); i++)
+  if ((*i).kw == key) { cards.erase(i);  break;  }
+}
+
+DataCards::Card *
+DataCards::FindKey(string const& key)
+{
+/*
+  CardList::iterator i = find_if(cards.begin(), cards.end(), bind2nd(KeyEq(),key));
+  if (i == cards.end() ) return NULL;
+*/
+  CardList::iterator i;
+  for(i=cards.begin(); i != cards.end(); i++)
+    if ((*i).kw == key) return &*i;
+
+  return NULL;
+}
+
+//++
+// Titre	Acces aux parametres
+//--
+//++
+// int   NbCards()
+//	Renvoie le nombre de cartes data
+// bool	 HasKey(string const& key) 
+//	Indique l'existence d'une carte avec la cle "key"
+// int   NbParam(string const& key)
+//	Indique le nombre de parametre (separes par des espaces) pour la cle "key"
+// string  SParam(string const& key, int num = 0, string def="")
+//	Renvoie la valeur du parametre numero "num" ( 0..(NbParam()-1) ) sous forme de
+//	chaine de caracteres ("string")
+// long    IParam(string const& key, int numero = 0, long def = 0)
+//	Renvoie la valeur du parametre numero "num" ( 0..(NbParam()-1) ) convertie 
+//	en entier ("long")
+// double  DParam(string const& key, int numero = 0, double def = 0)
+//	Renvoie la valeur du parametre numero "num" ( 0..(NbParam()-1) ) convertie 
+//	en flottant ("double")
+//--
+
+
+bool
+DataCards::HasKey(string const& key)
+{
+  return FindKey(key) != NULL;
+}
+
+int 
+DataCards::NbCards()
+{
+return(cards.size());
+}
+
+int 
+DataCards::NbParam(string const& key)
+{
+  DataCards::Card * p = FindKey(key);
+  if (!p) return(-1);
+  else return(p->tokens.size());
+}
+
+string
+DataCards::SParam(string const& key, int numero, string def)
+{
+  DataCards::Card * p = FindKey(key);
+  if (!p) return def;
+  if ( (numero < 0) || (numero >= p->tokens.size()) )  return def;
+  return p->tokens[numero];
+}
+
+long
+DataCards::IParam(string const& key, int numero, long def)
+{
+  string p = SParam(key, numero, "");
+  if (p == "") return def;
+  long i;
+  //istrstream(p.c_str(), p.length()) >> i;
+  sscanf(p.c_str(),"%ld",&i);
+  return i;
+}
+
+double
+DataCards::DParam(string const& key, int numero, double def)
+{
+  string p = SParam(key, numero, "");
+  if (p == "") return def;
+  double i;
+  //istrstream(p.c_str(), p.length()) >> i;
+  sscanf(p.c_str(),"%lg",&i);
+  return i;
+}
+
+   
+ostream& operator << (ostream& s, DataCards c)
+{
+  for (DataCards::CardList::iterator i = c.cards.begin(); i != c.cards.end(); i++) {
+    s << setw(10) << (*i).kw << " ";
+    for (vector<string>::iterator j = (*i).tokens.begin(); j != (*i).tokens.end(); j++)
+      s << (*j) << " ";
+    s << endl;
+  }
+  return s;
+}
+
+
+
Index: trunk/SophyaLib/SUtils/datacards.h
===================================================================
--- trunk/SophyaLib/SUtils/datacards.h	(revision 754)
+++ trunk/SophyaLib/SUtils/datacards.h	(revision 754)
@@ -0,0 +1,83 @@
+// This may look like C code, but it is really -*- C++ -*-
+//
+// $Id: datacards.h,v 1.1 2000-03-02 16:10:59 ansari Exp $
+//
+// Datacards, acquisition EROS II
+//
+//
+// Eric Aubourg, Decembre 95
+// Reza Ansari, Aout 96
+//
+// DAPNIA/SPP (Saclay) / CEA    LAL - IN2P3/CNRS  (Orsay)
+
+#ifndef DATACARDS_SEEN
+#define DATACARDS_SEEN
+
+#include <string.h>
+#include <string>
+#include <functional>
+#include <list>
+#include <vector>
+#include <string>
+
+#include "peida.h"
+
+typedef int (*ProcCard)(string const& key, string const& toks);
+ 
+class DataCards EXC_AWARE {
+public:
+   DataCards();                  
+   DataCards(string const& fn);
+
+           // nom dans variable d'environnement PEIDA_DATACARDS
+           // par defaut, peida.datacards                        
+           // Si pas chemin complet, on tente dans repertoire 
+           // en cours, puis dans PEIDA_WORK
+
+   virtual ~DataCards() {}
+
+   void    AddProcF(ProcCard f, string const& mtch="*");
+
+   void    Clear();
+   void    ReadFile(string const& fn);
+   void    AppendCard(string const& line);
+
+   int     NbCards();
+   bool    HasKey(string const& key);
+   int     NbParam(string const& key);
+   string  SParam(string const& key, int numero = 0, string def="");
+   long    IParam(string const& key, int numero = 0, long def = 0);
+   double  DParam(string const& key, int numero = 0, double def = 0);
+   
+   friend ostream& operator << (ostream& s, DataCards c);
+
+public:
+   struct Card {
+     string kw;
+     vector<string> tokens;
+	 STRUCTCOMPF(Card,kw)
+   };
+   typedef list<Card> CardList;
+   struct CrdPF {
+     ProcCard pf;
+     string  patt;
+	 STRUCTCOMPF(CrdPF,pf)
+   };
+   typedef list<CrdPF> CrdPFList;
+protected:
+   CardList cards;
+   CrdPFList cpfs;
+
+   void  DoReadFile(string const& fn);
+
+   int   ApplyPF(CrdPF & cpf, string const& key, string const& toks);
+   int   ApplyPFL(string const& key, string const& toks);
+
+   void  RemoveCard(string const& key);
+   
+   Card* FindKey(string const& key);
+   struct KeyEq : binary_function<Card, string, bool> {
+    bool operator()(const Card& x, const string& y) const { return x.kw == y; }
+   };
+};
+#endif
Index: trunk/SophyaLib/SUtils/strutil.c
===================================================================
--- trunk/SophyaLib/SUtils/strutil.c	(revision 754)
+++ trunk/SophyaLib/SUtils/strutil.c	(revision 754)
@@ -0,0 +1,534 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include "strutil.h"
+
+/* 
+++ 
+  Module	Strutil (C)
+  Lib	LibsUtil
+  include	strutil.h
+
+	Groupe de fonction de gestion et manipulation
+	des chaines de caracteres.
+--
+*/
+
+/*
+++
+  char* itoc(int in, char* s, int nDigits)
+	conversion entier-chaine de caracteres
+--
+*/
+/*
+++
+  ctoi(const char* cst, int *ipt)
+	convertit une chaine de caractere en entier
+--
+*/
+/*
+++
+  ctol(const char* cst, long int *lpt)
+	convertit une chaine de caractere en entier long
+--
+*/
+/*
+++
+  ctof(const char* cst, double *fpt)
+	convertit une chaine de caractere en flottant
+--
+*/
+/*
+++
+  posc(const char* cst, char sec)
+	trouve la position d'un caractere dans une chaine
+	(premier charactere rencontre)
+--
+*/
+/*
+++
+  poslc(const char* cst, char sec)
+	trouve la position d'un caractere dans une chaine
+	(dernier charactere rencontre)
+--
+*/
+/*
+++
+  strip(char cst[], char opt, char bc)
+	permet d'enlever les blancs au debut ou a la fin d'une
+	chaine de caractere
+--
+*/
+/*
+++
+  padstr(spo,lpa,bc)
+	Cette  fonction  rajoute  des blancs a la fin de la chaine `spo'
+	pour amener la longueur de la chaine a `lpa'. Les caracteres
+	rajoutes a la fin sont `bc'. La fonction retourne le nombre de
+	blancs (caracteres bc)  rajoutes a la fin.
+--
+*/
+/*
+++
+  tomaj(char *cbuff)
+	Changement en majuscule d'une chaine de caracteres
+--
+*/
+/*
+++
+  tomin(char *cbuff)
+	Changement en minuscule d'une chaine de caracteres
+--
+*/
+/*
+++
+  efface(char *cbuff,int lbuff,char c)
+	Remplace un caractere avec des blancs
+--
+*/
+/*
+++
+  csh_parse(const char* x, const char* yp)
+	Compare la chaine de caracteres `x' avec la chaine `yp'
+	comprenant des regles de substitution type c-shell
+	(asterisque et point d'interrogation).
+--
+*/
+/*
+  DecArgList()
+	Decoder une liste du type a,b,c-d,e,f-g,h...
+*/
+ 
+
+/*            Fonction  itoc()    */
+char* itoc(int in, char* s, int nDigits)
+{
+  int i,j,n;
+  n=abs(in);
+  for(i=0;i<nDigits;i++)
+    s[i]=' ';
+  s[nDigits-1]='\0';
+  j=nDigits-2;
+  for (i=j; i>=0; i--)
+   {
+    int x = n % 10;
+    n /= 10;
+    s[i] = '0' + x;
+    if(n==0) break;
+   }
+  if(in < 0 )
+   {
+    s[i-1]='-';
+   } 
+ return (s);
+ }
+ 
+/*            Fonction  ctoi()    */
+int ctoi(const char* cst, int *ipt)
+{
+int i,j,k,l,ls,isgn;
+ls = strlen(cst)-1;
+if (ls < 0)  return (-1);
+j = -1;
+isgn = l = 1;
+k = 0;
+if(cst[0] == '-')
+  {
+  j = 0;
+  isgn = -1;
+  }
+if(cst[0] == '+') j = 0;
+for(i=ls;i>j;i--)
+  {
+  if(isdigit(cst[i]) == 0)  return (-1);
+  k += (cst[i] - '0')*l;
+  l *= 10;
+  }
+*ipt = k*isgn;
+return (1);
+}
+/*                                                       */
+/*            Fonction  ctol()    */
+int ctol(const char* cst, long int *lpt)
+{
+int i,j,ls,isgn;
+long k,l;
+ls = strlen(cst)-1;
+if (ls < 0)  return (-1);
+j = -1;
+isgn = l = 1;
+k = 0;
+if(cst[0] == '-')
+  {
+  j = 0;
+  isgn = -1;
+  }
+if(cst[0] == '+') j = 0;
+for(i=ls;i>j;i--)
+  {
+  if(isdigit(cst[i]) == 0)  return (-1);
+  k += (cst[i] - '0')*l;
+  l *= 10;
+  }
+*lpt = k*isgn;
+return (1);
+}
+/*              Fonction  ctof()           */
+int ctof(const char* cst, double *fpt)
+{
+int i,jb,pv,ls,isgn;
+double v1,v2;
+ls = strlen(cst);
+if (ls < 0)  return (-1);
+jb = -1;
+isgn = 1;
+v1 = 0.;
+v2 = 1.;
+if (cst[0] == '-')
+  {
+  jb = 0;
+  isgn = -1;
+  }
+if (cst[0] == '+')  jb = 0;
+if ((pv=posc(cst,'.')) != -1)
+  {
+  v2 = 0.1;
+  for(i=pv+1;i<ls;i++)
+    {
+    if(isdigit(cst[i]) == 0)  return (-1);
+    v1 += (cst[i]-'0')*v2;
+    v2 /= 10.;
+    }
+  ls = pv;
+  v2 = 1.;
+  }
+for(i=ls-1;i>jb;i--)
+  {
+  if(isdigit(cst[i]) == 0)  return (-1);
+  v1 += (cst[i]-'0')*v2;
+  v2 *= 10.;
+  }
+*fpt = (isgn == 1)? v1 : -v1;
+return (1);
+}
+/*           Fonction  posc()        */
+int posc(const char* cst, char sec)
+{
+int i,ls;
+ls = strlen(cst);
+for(i=0;i<ls;i++)
+  {
+  if (cst[i] == sec)  return(i);
+  }
+return (-1);
+}
+
+/*           Fonction  poslc()        */
+int poslc(const char* cst, char sec)
+{
+int i,ls;
+ls = strlen(cst);
+for(i=ls-1;i>=0;i--)
+  {
+  if (cst[i] == sec)  return(i);
+  }
+return (-1);
+}
+
+/*                Fonction   strip()             */
+int strip(char cst[], char opt, char bc)
+{
+int i,j,ls;
+ls = strlen(cst);
+if (opt == 'L' || opt == 'B')
+  {
+  i = 0;
+  while(cst[i] == bc) i++;
+  if (i != 0)
+    {
+    for(j=i;j<ls;j++)  cst[j-i] = cst[j];
+    ls -= i;
+    cst[ls] = '\0';
+    }
+  }
+if ((opt == 'T' || opt == 'B') && ls > 0)
+  {
+  i = ls-1;
+  while(cst[i] == bc)  i--;
+  cst[i+1] = '\0';
+  }
+return (0);
+}
+
+/*                Fonction   padstr(spo,lpa,bc)                      */
+/*    Cette  fonction  rajoute  des blancs a la fin de la chaine spo */
+/*   pour amener la longueur de la chaine a lpa. les caracteres      */
+/*   rajoutes a la fin sont bc. La fonction retourne le nombre de    */ 
+/*   blancs (caracteres bc)  rajoutes a la fin.                      */
+
+int padstr(char spo[], int lpa, int bc)
+{
+int li,i;
+li = strlen(spo);
+for(i=li;i<lpa;i++)  spo[i] = bc;
+spo[lpa] = '\0';
+return(lpa-li);
+}
+
+/* Eric L. 11-03-94 */
+/* quelques fonctions utiles */
+
+void tomaj(char *cbuff)
+{
+register int i,l;
+
+l=strlen(cbuff);
+for(i=0; i< l;i++)
+  cbuff[i]=(char) toupper( (int) cbuff[i]);
+}
+
+void tomin(char *cbuff)
+{
+register int i,l;
+
+l=strlen(cbuff);
+for(i=0; i< l;i++)
+  cbuff[i]=(char) tolower( (int) cbuff[i]);
+}
+
+void efface(char *cbuff,int lbuff,char c)
+{
+register int i;
+
+for(i=0; i< lbuff;i++)
+  if(cbuff[i] == c)  cbuff[i] = ' ';
+}
+
+char* rep_char(const char *cbuff,char cin,char crep)
+{
+register int i,l;
+char* buff;
+buff=(char*) cbuff;
+l=strlen(buff);
+for(i=0; i< l;i++)
+  if(buff[i] == cin) buff[i] = crep;
+return(buff);
+}
+
+/* Eric L. 23-03-96 */
+
+int csh_parse(const char* x, const char* yp)
+{
+ int i,lenx,lenyp;
+ int ix,iyp;
+ int faux;
+ char cx, cyp;
+ 
+ lenx=strlen(x);
+ lenyp=strlen(yp);
+ if(!lenx || !lenyp) return(0);
+ faux=0;
+ ix=0;iyp=0;
+ while(ix < lenx && iyp < lenyp)
+  {
+   cx=x[ix];
+   cyp=yp[iyp];
+   if(cx == cyp) 
+    {
+     ix++; 
+     iyp++;
+    }
+   else
+    switch(cyp)
+     {
+       case '?':
+        ix++;
+        iyp++;
+        break;
+       case '*':
+        while((cyp=='*' || cyp=='?') && (iyp < lenyp))
+         {
+          iyp++;
+          if(iyp < lenyp) cyp=yp[iyp];
+         }
+        if(iyp < lenyp)
+         {
+          faux=1;
+          for(i = ix; i < lenx ; i++)
+           {
+            cx=x[i];
+            if(cx == cyp)
+             {
+              faux=0;
+              break;
+             }
+           }
+          ix=i+1;
+          if(ix < lenx) cx=x[ix];
+          iyp++; 
+          if(iyp < lenyp) cyp=yp[iyp];
+         }    
+        break;
+       default:
+        faux=1;
+     }
+    if(faux) return(0);
+  }
+ 
+ for( i= iyp; i < lenyp ; i++)
+  {
+   cyp=yp[i];
+   if( cyp != '*' && cyp != '?') return(0);
+  }
+ 
+ if(cyp == '*') return(1);
+ if((lenx-ix) == 1 && ( cyp == '?' || cx==cyp)) return(1);
+ for( i= ix; i < lenx ; i++)
+  {
+   cx=x[i];
+   if( cx != cyp)  return(0);
+  }
+ return(1);
+}
+ 
+/*-------------------------------------------------------------------*/
+
+/*
+++
+  int DecArgList(char *listin, int *Vec, int nVec)
+	Pour decoder une liste de numeros a,b,c-d,e,f-g,h...
+	avec a,b... entiers
+| Vec est rempli jusqu'a concurrence de nVec elts.
+|     Si Vec==NULL ou nVec<=0 le tableau n'est pas rempli
+|         et seul le nombre d'elements est compte
+| Return: nombre d'elements rempli
+--
+*/
+/*                            (cmv 7/8/97)      */
+int DecArgList(char *listin, int *Vec, int nVec)
+{
+int i,k, num, min, max;
+char *list = NULL, *listfin, *s;
+
+if(strlen(listin) <= 0) return(0);
+list = (char *) malloc(strlen(listin)+1);
+if(list==NULL) return(0);
+strcpy(list,listin); strip(list,'B',' ');
+if( (k=strlen(list)) <= 0 ) {free(list); return(0);}
+for(i=0; i<k; i++) if(list[i] == ',') list[i] = ' ';
+listfin = list + k; *listfin = '\0';
+
+s = list; num = 0; k = 0;
+while(s < listfin) {
+  if ( (k=posc(s,' ')) < 0)  k = strlen(s);
+  s[k] = '\0'; strip(s,'B',' ');
+  sscanf(s,"%d-%d",&min,&max);
+  max = min - 1;
+  sscanf(s,"%d-%d",&min,&max);
+  if(max<min) max = min;
+  for(i=min; i<=max; i++) {
+    if( Vec!=NULL && nVec>0 ) {
+      if( num >= nVec )
+        {printf("DecArgList_Erreur: pas assez de place dans le vecteur (%d)\n"
+               ,nVec); free(list); return(num);}
+      Vec[num] = i;
+    }
+    num++;
+  }
+  s = s+k+1;
+}
+
+free(list);
+return(num);
+}
+ 
+/*-------------------------------------------------------------------*/
+
+/*
+++
+  char *ExtName(char *cout,char *cin,char t)
+	Pour separer les composantes d'un nom de fichier de type unix.
+| cout   = chaine en sortie
+| cin    = chaine en entree
+| t      = type de racine a extraire
+| Return = *cout
+| - Remarque: pas de verification de longeur de la chaine cout!
+| - Exemple: /home/toto.cc  /home/ /home/.cc  .cc  toto.cc
+|    t='d' : /home          /home  /home      ""   ""
+|    t='n' : toto.cc        ""     .cc        .cc  toto.cc
+|    t='r' : toto           ""     ""         ""   toto
+|    t='t' : cc             ""     cc         cc   cc
+--
+*/
+/*                            (cmv 24/4/98)      */
+char *ExtName(char *cout,char *cin,char t)
+{
+int is=-1,ip=-1,i,j;
+int len = strlen(cin);
+/* cas ou le nom se termine par un / qui n'est pas au debut*/
+if(len>1) if(cin[len-1]=='/') len--;
+
+for(i=0;i<len;i++) {
+  if(cin[i]=='/') is=i;         /* position du dernier / */
+  if(cin[i]=='.' && ip<0) ip=i; /* position du 1er point */
+  cout[i]=cin[i];
+}
+cout[len]='\0';
+
+/* mauvais nom de fichier */
+if(is>=0&&ip>=0&&ip<=is) {cout[0]='\0'; return cout;}
+
+/* traitement des differents cas */
+switch(t) {
+  case 'd':
+    if(is==0) {                    /* cas /... */
+      if(ip<0) ip=len-1;             /* cas /home */
+      else ip=0;                     /* cas /toto.c */
+    } else if(is<0) {              /* cas toto.c */
+      is=ip=-1;
+    } else {                       /* cas /home/.../... */
+      ip=is-1; is=0;
+    }
+    break;
+  case 'n':
+    if(is==0) {                        /* cas /... */
+      if(ip<0) ip=is=-1;                 /* cas /home */
+      else {is=1; ip=len-1;}             /* cas /toto.c */
+    } else if(is>0) {                  /* cas /home/toto.c */
+      is++; ip=len-1;
+    } else {                           /* cas toto.c */
+      is=0; ip=len-1;
+    }
+    break;
+  case 'r':
+    if(is==0) {                          /* cas /... */
+      if(ip<0) ip=is=-1;                   /* cas /home */
+      else if(ip==1) is=ip=-1;             /* cas /.c */
+      else {is=1; ip--;}                   /* cas /toto.c */
+    } else if(is>0) {                    /* cas /home/... */
+      if(ip<0) {is++;ip=len-1;}            /* cas /home/toto */
+      else if(ip==is+1) is=ip=-1;          /* cas /home/.c */
+      else {is++; ip--;}                   /* cas /home/toto.c */
+    } else if(is<0) {                    /* cas toto.c */
+      if(ip<0) {is=0;ip=len-1;}            /* cas toto */
+      else if(ip==0) is=ip=-1;             /* cas .c */
+      else {is=0; ip--;}                   /* cas toto.c */
+    }
+    break;
+  case 't':
+    if(ip<0) is=ip=-1;             /* cas sans '.' dans le nom */
+    else {is=ip+1,ip=len-1;}       /* cas blablabla.c */
+    break;
+  default:
+    cout[0]='\0';
+    return cout;
+    break;
+}
+
+j=0;
+if(is>=0&&ip>=is) for(i=is,j=0;i<=ip;i++,j++) cout[j]=cin[i];
+cout[j]='\0';
+/* printf("........ is=%d ip=%d :%s:\n",is,ip,cout); */
+return cout;
+}
Index: trunk/SophyaLib/SUtils/strutil.h
===================================================================
--- trunk/SophyaLib/SUtils/strutil.h	(revision 754)
+++ trunk/SophyaLib/SUtils/strutil.h	(revision 754)
@@ -0,0 +1,58 @@
+/*                                                                          */
+/*   Ce fichier contient quelques fonctions de manipulation de caracteres   */
+/*   et autres bricoles utiles                                              */
+/*     # char* itoc() : conversion entier-chaine de caracteres              */ 
+/*     # ctoi()   : convertit une chaine de caractere en entier             */
+/*     # ctol()   : convertit une chaine de caractere en entier long        */
+/*     # ctof()   : convertit une chaine de caractere en flottant           */
+/*     # posc()    : trouve la position d'un caractere dans une chaine      */
+/*     # strip()  : permet d'enlever les blancs au debut ou a la fin d'une  */
+/*                  chaine de caractere                                     */ 
+/*     # padstr() : permet d'ajouter des caracteres a la fin d'une chaine   */
+/*                  de caracteres pour amener la longueur de cette chaine   */
+/*                  a une valeur donnee.                                    */
+/*     # tomaj()  : Changement en majuscule d'une chaine de caracteres      */
+/*     # efface() : Remplace un caractere avec des blancs                   */
+/*     # rep_char() : Remplace un caractere par un autre                    */ 
+/*                                                                          */
+/* Derniere modif: csh_parse, E. Lesquoy, le 23-03-96                       */
+/* DecArgList: Decoder une liste du type a,b,c-d,e,f-g,h...(cmv 7/8/97)     */
+/* ExtName: eclatement des nom de fichiers unix (cmv 24/4/98)               */
+
+#ifndef STRUTIL_H_SEEN
+#define STRUTIL_H_SEEN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*    Manipulation de chaines de caracteres     */
+/*                    Reza - 92/93              */
+char* itoc(int in, char* s,int nDigits);
+int ctoi(const char* cst, int *ipt);
+int ctol(const char* cst, long int *lpt);
+int ctof(const char* cst, double *fpt);
+/* retour ctox : 1: OK, -1 erreur */
+int posc(const char* cst, char sec);
+int poslc(const char* cst, char sec);
+int strip(char* cst, char opt, char bc);
+int padstr(char* spo, int lpa, int bc);
+
+/* Eric L. 11-03-94 */
+void tomaj(char *cbuff);
+void tomin(char *cbuff);
+void efface(char *cbuff,int lbuff,char c);
+/* Attention rep_char(const char *cbuff ...) c'est declare const cbuff, mais ca modifie cbuff - Reza 2/09/98  */
+char* rep_char(const char *cbuff,char cin,char crep);  
+/* Eric L. 23-03-96 */
+int csh_parse(const char* x, const char* yp);
+/* cmv 7/8/97 */
+int DecArgList(char *listin, int *Vec, int nVec);
+char *ExtName(char *cin,char *cout,char t);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
