Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Component_generate_file.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Component_generate_file.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Component_generate_file.cpp	(revision 88)
@@ -8,8 +8,11 @@
 
 #include "Behavioural/include/Component.h"
+#include "Common/include/Environment.h"
 
 namespace morpheo              {
 namespace behavioural          {
 
+#undef  FUNCTION
+#define FUNCTION "Component::generate_file"
   void Component::generate_file (void)
   {
@@ -18,14 +21,16 @@
     try 
       {
+        directory();
+
 	XML xml = toXML();
 
-	xml.filename_extension ("pos");
+	xml.filename_extension (".pos");
 	
-	xml.generate_file("ISO-8859-1");
+	xml.generate_file(MORPHEO_POSITION,"ISO-8859-1");
 
       }
     catch (ErrorMorpheo e)
       {
-	throw (ErrorMorpheo ("Component \""+_entity->get_name()+"\" have a bad mapping : "+e.what()));
+	throw ERRORMORPHEO(FUNCTION,toString(_("Component \"%s\" have a bad mapping : %s\n")),_entity->get_name().c_str(),e.what().c_str());
       }
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Component_port_map.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Component_port_map.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Component_port_map.cpp	(revision 88)
@@ -20,5 +20,5 @@
     log_printf(FUNC,Behavioural,FUNCTION,"Begin");
 
-//     log_printf(NONE,Behavioural,FUNCTION,"Map %s.%s with %s.%s",
+//     log_printf(INFO,Behavioural,FUNCTION,"Map %s.%s with %s.%s",
 // 	       component_src.c_str(),
 // 	       port_src.c_str(),
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Component_test_map.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Component_test_map.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Component_test_map.cpp	(revision 88)
@@ -15,5 +15,5 @@
   bool Component::test_map (bool recursive)
   {
-    log_printf(NONE,Behavioural,FUNCTION, "Test port map and interface.");
+    log_printf(INFO,Behavioural,FUNCTION, "Test port map and interface.");
     return test_map (0, recursive);
   }
@@ -23,5 +23,5 @@
     log_printf(FUNC,Behavioural,FUNCTION,"Begin");
 
-    std::string tab  = std::string(depth,'\t');
+    std::string tab  = std::string(depth,' ');
     std::string name = _entity->get_name();
     bool test_ok = true;
@@ -30,17 +30,17 @@
     if (is_behavioural)
       {
-	log_printf(NONE,Behavioural,FUNCTION, "%s* Component \"%s\" is a behavioural description",tab.c_str(),name.c_str());
+	log_printf(INFO,Interface,FUNCTION, "%s* Component \"%s\" is a behavioural description",tab.c_str(),name.c_str());
       }
     else
       {
-	log_printf(NONE,Behavioural,FUNCTION, "%s* Component \"%s\" is a structural description",tab.c_str(),name.c_str());
+	log_printf(INFO,Interface,FUNCTION, "%s* Component \"%s\" is a structural description",tab.c_str(),name.c_str());
       }
 
     
-    // 	log_printf(NONE,Behavioural,FUNCTION, "%s* Test port I/O",tab.c_str());
+    // 	log_printf(INFO,Behavioural,FUNCTION, "%s* Test port I/O",tab.c_str());
     
     test_ok &= _entity->test_map(depth+1,true,is_behavioural);
     
-    // 	log_printf(NONE,Behavioural,FUNCTION, "%s* Test all internal component",tab.c_str());
+    // 	log_printf(INFO,Behavioural,FUNCTION, "%s* Test all internal component",tab.c_str());
 	
     for (std::list<Tcomponent_t *>::iterator i= _list_component->begin();
@@ -72,5 +72,5 @@
 //   bool Component::test_equi (bool recursive)
 //   {
-//     log_printf(NONE,Behavioural,FUNCTION, "Test port equi and interface.");
+//     log_printf(INFO,Behavioural,FUNCTION, "Test port equi and interface.");
 //     return test_equi (0, recursive);
 //   }
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Configuration_Parameters.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Configuration_Parameters.cpp	(revision 85)
+++ 	(revision )
@@ -1,50 +1,0 @@
-#ifdef CONFIGURATION
-/*
- * $Id$
- *
- * [ Description ]
- * 
- */
-
-#include "Behavioural/include/Configuration_Parameters.h"
-
-namespace morpheo              {
-namespace behavioural          {
-    
-#undef  FUNCTION
-#define FUNCTION "Configuration_Parameters::Configuration_Parameters"
-  Configuration_Parameters::Configuration_Parameters  (std::string   name   ,
-						       uint32_t value  ,
-						       uint32_t min    ,
-						       uint32_t max    ,
-						       std::string   step   ,
-						       uint32_t value_default,
-						       uint32_t level  ,
-						       std::string   comment):
-    _name    (name         ),
-    _value   (value        ),
-    _min     (min          ),
-    _max     (max          ),
-    _step    (step         ),
-    _default (value_default),
-    _level   (level        ),
-    _comment (comment      )
-  {
-    log_printf(FUNC,Behavioural,FUNCTION,"Begin");
-    if ((value<min) or (value>max))
-      throw (ErrorMorpheo ("Parameters \""+name+"\" is out of bound : "+toString(value)+" not include in ["+toString(min)+":"+toString(max)+"]"));
-    log_printf(FUNC,Behavioural,FUNCTION,"End");
-  };
-    
-
-#undef  FUNCTION
-#define FUNCTION "Configuration_Parameters::~Configuration_Parameters"
-  Configuration_Parameters::~Configuration_Parameters () 
-  {
-    log_printf(FUNC,Behavioural,FUNCTION,"Begin");
-    log_printf(FUNC,Behavioural,FUNCTION,"End");
-  };
-
-}; // end namespace behavioural          
-}; // end namespace morpheo              
-#endif
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Configuration_Parameters_print.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Configuration_Parameters_print.cpp	(revision 85)
+++ 	(revision )
@@ -1,51 +1,0 @@
-#ifdef CONFIGURATION
-/*
- * $Id$
- *
- * [ Description ]
- * 
- */
-
-#include "Behavioural/include/Configuration_Parameters.h"
-
-
-namespace morpheo              {
-namespace behavioural          {
-
-#undef  FUNCTION
-#define FUNCTION "Configuration_Parameters::print"
-  std::string Configuration_Parameters::print (uint32_t depth)
-  {
-    log_printf(FUNC,Behavioural,FUNCTION,"Begin");
-    XML * xml = new XML (_name);
-    
-    xml->balise_open_begin("generic");
-    xml->  attribut("name"   ,         _name  );
-    xml->  attribut("value"  ,toString(_value));
-    xml->  attribut("min"    ,toString(_min  ));
-    xml->  attribut("max"    ,toString(_max  ));
-    xml->  attribut("step"   ,         _step  );
-    xml->  attribut("default",toString(_value));
-    xml->  attribut("level"  ,toString(_level));
-    xml->balise_open_end  ();
-    xml->  text  (_comment);
-    xml->balise_close();
-    
-    log_printf(FUNC,Behavioural,FUNCTION,"End");
-    return xml->get_body(depth);
-  };
-  
-#undef  FUNCTION
-#define FUNCTION "Configuration_Parameters::operator<<"
-  std::ostream& operator<< (std::ostream& output_stream,
-			    morpheo::behavioural::Configuration_Parameters & x)
-  {
-    log_printf(FUNC,Behavioural,FUNCTION,"Begin");
-    output_stream << x.print(0);
-    log_printf(FUNC,Behavioural,FUNCTION,"End");
-    return output_stream;
-  };
-
-}; // end namespace behavioural          
-}; // end namespace morpheo              
-#endif
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Entity_test_map.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Entity_test_map.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Entity_test_map.cpp	(revision 88)
@@ -18,6 +18,6 @@
     log_printf(FUNC,Behavioural,FUNCTION,"Begin");
   
-    std::string tab  = std::string(depth,'\t');
-    log_printf(NONE,Behavioural,FUNCTION, "%s* Entity \"%s\"",tab.c_str(),_name.c_str());
+    std::string tab  = std::string(depth,' ');
+    log_printf(INFO,Interface,FUNCTION,"%s* Entity \"%s\"",tab.c_str(),_name.c_str());
   
     bool _return = _interfaces->test_map(depth+1,top_level, is_behavioural);
@@ -42,5 +42,5 @@
   
 //     std::string tab  = std::string(depth,'\t');
-//     log_printf(NONE,Behavioural,FUNCTION, "%s* Entity \"%s\"",tab.c_str(),_name.c_str());
+//     log_printf(INFO,Behavioural,FUNCTION, "%s* Entity \"%s\"",tab.c_str(),_name.c_str());
   
 //     bool _return = _interfaces->test_equi(depth+1);
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_fifo_testbench_assert.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_fifo_testbench_assert.cpp	(revision 88)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_fifo_testbench_assert.cpp	(revision 88)
@@ -0,0 +1,51 @@
+#ifdef VHDL_TESTBENCH
+#ifdef VHDL_TESTBENCH_ASSERT
+/*
+ * $Id$
+ *
+ * [ Description ]
+ * 
+ */
+
+#include "Behavioural/include/Interface_fifo.h"
+
+namespace morpheo              {
+namespace behavioural          {
+
+#undef  FUNCTION
+#define FUNCTION "Interface_fifo::testbench_assert"
+  void Interface_fifo::testbench_assert (Vhdl * & vhdl,
+                                         std::string counter_name)
+  {
+    log_printf(FUNC,Behavioural,FUNCTION,"Begin");
+    
+    if (not _test_exhaustive)
+      if (_list_cycle->empty()== false)
+        {
+          std::string test_name = Interface::testbench_test_name(vhdl);
+
+          vhdl->set_body("");
+          vhdl->set_body("-- Interface \""+_name+"\"");
+          vhdl->set_body("");
+          
+          uint32_t j = 0;
+          std::list<uint32_t>::iterator i = _list_cycle->begin();
+          
+          while (i != _list_cycle->end())
+            {
+              vhdl->set_body("assert not (("+counter_name+" = "+toString(*i)+" and "+test_name+" = '1')) report \"***** <"+_name+"> Test number "+toString(j)+" is OK     *****\" severity NOTE;");
+              vhdl->set_body("assert not (("+counter_name+" = "+toString(*i)+" and "+test_name+" = '0')) report \"@@@@@ <"+_name+"> Test number "+toString(j)+" is KO !!! @@@@@\" severity NOTE;");
+              j++;
+              ++i;
+            }
+          
+          vhdl->set_body("");
+        }
+    
+    log_printf(FUNC,Behavioural,FUNCTION,"End");
+  };
+
+}; // end namespace behavioural          
+}; // end namespace morpheo              
+#endif
+#endif
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_fifo_testbench_test.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_fifo_testbench_test.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_fifo_testbench_test.cpp	(revision 88)
@@ -13,6 +13,6 @@
 
   std::string Interface_fifo::testbench_test (Vhdl * & vhdl,
-					 std::string   counter_name,
-					 std::string   reset_name  )
+                                              std::string   counter_name,
+                                              std::string   reset_name  )
   {
     log_printf(FUNC,Behavioural,"testbench_test","Begin");
@@ -27,5 +27,5 @@
 	vhdl->set_body("");
 
-	       test_name        = testbench_test_name        (vhdl);
+	            test_name        = testbench_test_name        (vhdl);
 	std::string test_name_tmp    = test_name+"_tmp";
 	std::string test_name_ok     = testbench_test_ok          (vhdl);
@@ -54,25 +54,25 @@
 	vhdl->set_body(test_name + " <= '1' when ("+reset_name+" = '0') else "+test_name_tmp+";");
 
-#ifdef VHDL_TESTBENCH_ASSERT
-	if (_list_cycle->empty()== false)
-	  {
-	    vhdl->set_body("");
-	    vhdl->set_body("-- Assert ...");
-	    vhdl->set_body("");
+// #ifdef VHDL_TESTBENCH_ASSERT
+// 	if (_list_cycle->empty()== false)
+// 	  {
+// 	    vhdl->set_body("");
+// 	    vhdl->set_body("-- Assert ...");
+// 	    vhdl->set_body("");
 
-	    uint32_t                 j = 0;
-	    std::list<uint32_t>::iterator i = _list_cycle->begin();
+// 	    uint32_t                 j = 0;
+// 	    std::list<uint32_t>::iterator i = _list_cycle->begin();
 	    
-	    while (i != _list_cycle->end())
-	      {
-		vhdl->set_body("assert not (("+counter_name+" = "+toString(*i)+" and "+test_name+" = '1')) report \"***** <"+_name+"> Test number "+toString(j)+" is OK     *****\" severity NOTE;");
-		vhdl->set_body("assert not (("+counter_name+" = "+toString(*i)+" and "+test_name+" = '0')) report \"@@@@@ <"+_name+"> Test number "+toString(j)+" is KO !!! @@@@@\" severity NOTE;");
-		j++;
-		++i;
-	      }
+// 	    while (i != _list_cycle->end())
+// 	      {
+// 		vhdl->set_body("assert not (("+counter_name+" = "+toString(*i)+" and "+test_name+" = '1')) report \"***** <"+_name+"> Test number "+toString(j)+" is OK     *****\" severity NOTE;");
+// 		vhdl->set_body("assert not (("+counter_name+" = "+toString(*i)+" and "+test_name+" = '0')) report \"@@@@@ <"+_name+"> Test number "+toString(j)+" is KO !!! @@@@@\" severity NOTE;");
+// 		j++;
+// 		++i;
+// 	      }
 
-	    vhdl->set_body("");
-	  }
-#endif
+// 	    vhdl->set_body("");
+// 	  }
+// #endif
       }
 
@@ -80,5 +80,4 @@
 
     return test_name;
-
   };
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_set_signal.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_set_signal.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_set_signal.cpp	(revision 88)
@@ -11,5 +11,5 @@
 namespace behavioural          {
 
-  Signal * Interface::set_signal (std::string          name     ,
+  Signal * Interface::set_signal (std::string     name     ,
 				  direction_t     direction,
 				  uint32_t        size     ,
@@ -19,5 +19,5 @@
 
     std::string signame = signal_name(_name, name, direction);
-
+    
     Signal * sig = new Signal       (signame, direction, size, presence_port);
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_test_map.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_test_map.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_test_map.cpp	(revision 88)
@@ -18,8 +18,8 @@
     log_printf(FUNC,Behavioural,FUNCTION,"Begin");
 
-    std::string tab  = std::string(depth,'\t');
+    std::string tab  = std::string(depth,' ');
     bool _return = true;
 
-    log_printf(NONE,Behavioural,FUNCTION, "%s* Interface \"%s\"",tab.c_str(),_name.c_str());
+    log_printf(INFO,Interface,FUNCTION, "%s* Interface \"%s\"",tab.c_str(),_name.c_str());
     
     for (std::list<Signal*>::iterator i  = _list_signal->begin();
@@ -42,5 +42,5 @@
 //     bool _return = true;
 
-//     log_printf(NONE,Behavioural,FUNCTION, "%s* Interface \"%s\"",tab.c_str(),_name.c_str());
+//     log_printf(INFO,Behavioural,FUNCTION, "%s* Interface \"%s\"",tab.c_str(),_name.c_str());
     
 //     for (std::list<Signal*>::iterator i  = _list_signal->begin();
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interfaces_test_map.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interfaces_test_map.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interfaces_test_map.cpp	(revision 88)
@@ -18,9 +18,9 @@
     log_printf(FUNC,Behavioural,FUNCTION,"Begin");
 
-    std::string tab  = std::string(depth,'\t');
+    std::string tab  = std::string(depth,' ');
 
     bool _return = true;
 
-    log_printf(NONE,Behavioural,FUNCTION, "%s* Interfaces \"%s\"",tab.c_str(),_name.c_str());
+    log_printf(INFO,Interface,FUNCTION, "%s* Interfaces \"%s\"",tab.c_str(),_name.c_str());
     
     for (std::list<Interface_fifo*>::iterator i  = _list_interface->begin();
@@ -44,5 +44,5 @@
 //     bool _return = true;
 
-//     log_printf(NONE,Behavioural,FUNCTION, "%s* Interfaces \"%s\"",tab.c_str(),_name.c_str());
+//     log_printf(INFO,Behavioural,FUNCTION, "%s* Interfaces \"%s\"",tab.c_str(),_name.c_str());
     
 //     for (std::list<Interface_fifo*>::iterator i  = _list_interface->begin();
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interfaces_testbench_generate_file.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interfaces_testbench_generate_file.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interfaces_testbench_generate_file.cpp	(revision 88)
@@ -17,11 +17,11 @@
     log_printf(FUNC,Behavioural,"generate_file","Begin");
 
-    Vhdl   * vhdl        = new Vhdl(_name+"_Testbench");
-    std::string   counter     = "counter";
-    Signal * clock       = this->get_clock();
-    Signal * reset       = this->get_reset();
-    std::string   clock_name  = clock->get_name();
-    std::string   reset_name  = reset->get_name();
-    uint32_t cycle       = this->get_cycle();
+    Vhdl   *    vhdl        = new Vhdl(_name+"_Testbench");
+    std::string counter     = "counter";
+    Signal *    clock       = this->get_clock();
+    Signal *    reset       = this->get_reset();
+    std::string clock_name  = clock->get_name();
+    std::string reset_name  = reset->get_name();
+    uint32_t    cycle       = this->get_cycle();
 
     vhdl->set_signal    (clock_name, 1, 0);
@@ -87,14 +87,25 @@
     vhdl->set_body("\t\t\t"+counter+" <= "+counter+"+1;");
     vhdl->set_body("");
-    vhdl->set_body("\t\t\tassert not ("+counter+" >= "+toString(cycle)+") report \"Test OK\" severity FAILURE;");
-    vhdl->set_body("\t\t\tassert not ("+test_name+" = '0') report \"Test KO\" severity FAILURE;");
-
 #ifdef VHDL_TESTBENCH_ASSERT
-    vhdl->set_body("\t\t\t-- Assert ...");
     for (uint32_t cpt=0; cpt<=cycle; cpt++)
       vhdl->set_body("\t\t\tassert not ("+counter+" = "+toString(cpt)+") report \"===== Test number "+toString(cpt)+" =====\" severity NOTE;");
+
+    for (std::list<Interface_fifo*>::iterator it=_list_interface->begin();
+         it!=_list_interface->end();
+         ++it)
+      {
+        Vhdl * vhdl_assert = new Vhdl("");
+
+        (*it)->testbench_assert (vhdl_assert,counter);
+
+        vhdl->set_body(vhdl_assert);
+        
+        delete vhdl_assert;
+      }
 #endif
 
     vhdl->set_body("");
+    vhdl->set_body("\t\t\tassert not ("+counter+" >= "+toString(cycle)+") report \"Test OK\" severity FAILURE;");
+    vhdl->set_body("\t\t\tassert not ("+test_name+" = '0') report \"Test KO\" severity FAILURE;");
     vhdl->set_body("\t\tend if;");
     vhdl->set_body("\tend if;");
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Parameters_copy.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Parameters_copy.cpp	(revision 88)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Parameters_copy.cpp	(revision 88)
@@ -0,0 +1,76 @@
+/*
+ * $Id$
+ *
+ * [ Description ]
+ * 
+ */
+
+#include "Behavioural/include/Parameters.h"
+
+namespace morpheo              {
+namespace behavioural          {
+
+#undef  FUNCTION
+#define FUNCTION "Parameters::duplicate" 
+  void Parameters::duplicate (Parameters * param)
+  {
+    param->_simulation_nb_cyle                    = _simulation_nb_cyle                    ;
+    param->_simulation_nb_instruction             = _simulation_nb_instruction             ;
+
+    param->_size_context_id                       = _size_context_id                       ;
+    param->_have_port_context_id                  = _have_port_context_id                  ;
+    
+    param->_size_front_end_id                     = _size_front_end_id                     ;
+    param->_have_port_front_end_id                = _have_port_front_end_id                ;
+
+    param->_size_ooo_engine_id                    = _size_ooo_engine_id                    ;
+    param->_have_port_ooo_engine_id               = _have_port_ooo_engine_id               ;
+
+    param->_size_instruction_address              = _size_instruction_address              ;
+//  param->_have_port_instruction_address         = _have_port_instruction_address         ; // always true
+    
+    param->_size_data_address                     = _size_data_address                     ;
+//  param->_have_port_data_address                = _have_port_data_address                ; // always true
+
+    param->_size_nb_inst_decod                    = _size_nb_inst_decod                    ;
+//  param->_have_port_nb_inst_decod               = _have_port_nb_inst_decod               ; // always true
+
+    param->_size_nb_inst_commit                   = _size_nb_inst_commit                   ;
+//  param->_have_port_nb_inst_commit              = _have_port_nb_inst_commit              ; // always true
+
+    param->_size_depth                            = _size_depth                            ;
+    param->_have_port_depth                       = _have_port_depth                       ;
+
+    param->_size_ifetch_queue_ptr                 = _size_ifetch_queue_ptr                 ;
+    param->_have_port_ifetch_queue_ptr            = _have_port_ifetch_queue_ptr            ;
+
+    param->_size_inst_ifetch_ptr                  = _size_inst_ifetch_ptr                  ; // nb_inst_fetch
+    param->_have_port_inst_ifetch_ptr             = _have_port_inst_ifetch_ptr             ;
+
+//  param->_size_branch_update_prediction_id      = _size_branch_update_prediction_id      ; // = size_depth
+//  param->_have_port_branch_update_prediction_id = _have_port_branch_update_prediction_id ; // = size_depth
+
+    param->_size_rob_ptr                          = _size_rob_ptr                          ;
+    param->_have_port_rob_ptr                     = _have_port_rob_ptr                     ;
+
+    param->_size_load_queue_ptr                   = _size_load_queue_ptr                   ;
+    param->_have_port_load_queue_ptr              = _have_port_load_queue_ptr              ;
+
+    param->_size_store_queue_ptr                  = _size_store_queue_ptr                  ;
+//  param->_have_port_store_queue_ptr             = _have_port_store_queue_ptr             ; // always true (min = 1)
+
+    param->_size_general_data                     = _size_general_data                     ;
+//  param->_have_port_general_data                = _have_port_general_data                ; // always true
+
+    param->_size_special_data                     = _size_special_data                     ;
+//  param->_have_port_special_data                = _have_port_special_data                ; // always true
+
+    param->_size_general_register                 = _size_general_register                 ;
+//  param->_have_port_general_register            = _have_port_general_register            ; // always true
+
+    param->_size_special_register                 = _size_special_register                 ;
+//  param->_have_port_special_register            = _have_port_special_register            ; // always true
+  }
+
+}; // end namespace behavioural          
+}; // end namespace morpheo              
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Parameters_test.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Parameters_test.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Parameters_test.cpp	(revision 88)
@@ -23,5 +23,5 @@
 
     if (x.have_error())
-      throw (ErrorMorpheo ("Error(s) in parameters"));
+      throw ERRORMORPHEO (FUNCTION,_("Error(s) in parameters\n"));
 
     log_printf(FUNC,Behavioural,FUNCTION,"End");
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/SPR_access_mode_exist.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/SPR_access_mode_exist.cpp	(revision 88)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/SPR_access_mode_exist.cpp	(revision 88)
@@ -0,0 +1,24 @@
+#include "Behavioural/include/SPR_access_mode.h"
+
+namespace morpheo {
+namespace behavioural {
+
+  bool SPR_access_mode::exist (spr_address_t address)
+  {
+    return exist(address._group, address._register);
+  }
+  
+  bool SPR_access_mode::exist (uint32_t num_group, uint32_t num_reg)
+  {
+    if (not valid(num_group, num_reg))
+      return false;
+
+    spr_access_mode_t mode = _spr_generic [num_group][num_reg];
+
+    return ((mode._supervisor_access_mode != SPR_ACCESS_MODE_NONE) or
+	    (mode._user_access_mode       != SPR_ACCESS_MODE_NONE));
+  }
+
+}; // end namespace behavioural
+}; // end namespace morpheo              
+
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/SPR_access_mode_implement_group.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/SPR_access_mode_implement_group.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/SPR_access_mode_implement_group.cpp	(revision 88)
@@ -28,4 +28,6 @@
     	    for (uint32_t i=16; i<=18; i++)
     	    _spr_generic [GROUP_SYSTEM_AND_CONTROL ][   i]._supervisor_access_mode = SPR_ACCESS_MODE_READ_WRITE;
+    	    _spr_generic [GROUP_SYSTEM_AND_CONTROL ][  19]._user_access_mode       = SPR_ACCESS_MODE_READ_ONLY;
+    	    _spr_generic [GROUP_SYSTEM_AND_CONTROL ][  19]._supervisor_access_mode = SPR_ACCESS_MODE_READ_WRITE;
     	    _spr_generic [GROUP_SYSTEM_AND_CONTROL ][  20]._user_access_mode       = SPR_ACCESS_MODE_READ_ONLY_COND;
     	    _spr_generic [GROUP_SYSTEM_AND_CONTROL ][  20]._supervisor_access_mode = SPR_ACCESS_MODE_READ_WRITE;
@@ -77,5 +79,5 @@
 
 	    _spr_generic [GROUP_DCACHE             ][   0]._supervisor_access_mode = SPR_ACCESS_MODE_READ_WRITE;
-	    for (uint32_t i=0; i<=5; i++)
+	    for (uint32_t i=1; i<=5; i++)
 	    	{
 	    _spr_generic [GROUP_DCACHE             ][   i]._supervisor_access_mode = SPR_ACCESS_MODE_WRITE_ONLY;
@@ -91,5 +93,5 @@
 
 	    _spr_generic [GROUP_ICACHE             ][   0]._supervisor_access_mode = SPR_ACCESS_MODE_READ_WRITE;
-	    for (uint32_t i=0; i<=3; i++)
+	    for (uint32_t i=1; i<=3; i++)
 	    	{
 	    _spr_generic [GROUP_ICACHE             ][   i]._supervisor_access_mode = SPR_ACCESS_MODE_WRITE_ONLY;
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/SPR_access_mode_invalid_register.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/SPR_access_mode_invalid_register.cpp	(revision 88)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/SPR_access_mode_invalid_register.cpp	(revision 88)
@@ -0,0 +1,14 @@
+#include "Behavioural/include/SPR_access_mode.h"
+
+namespace morpheo {
+namespace behavioural {
+
+  void SPR_access_mode::invalid_register (uint32_t num_group, uint32_t num_reg)
+  {
+    if (valid(num_group, num_reg))
+      change_mode (num_group, num_reg, spr_access_mode_t(SPR_ACCESS_MODE_NONE,SPR_ACCESS_MODE_NONE));
+  }
+
+}; // end namespace behavioural
+}; // end namespace morpheo              
+
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/SPR_access_mode_read_write.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/SPR_access_mode_read_write.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/SPR_access_mode_read_write.cpp	(revision 88)
@@ -1,3 +1,5 @@
 #include "Behavioural/include/SPR_access_mode.h"
+
+#include "Common/include/Debug.h"
 
 namespace morpheo {
@@ -14,8 +16,15 @@
   bool SPR_access_mode::read (spr_address_t address, Tcontrol_t SM, Tcontrol_t SUMRA)
     {
-      if (not valid(address))
+//       log_printf(TRACE,true,"SPR_access_mode::read","address [%d][%d]",address._group,address._register);
+//       log_printf(TRACE,true,"SPR_access_mode::read","sm        : %d",SM   );
+//       log_printf(TRACE,true,"SPR_access_mode::read","sumra     : %d",SUMRA);
+
+      if (not exist(address))
 	return false;
 
       spr_access_mode_t mode = _spr_generic [address._group][address._register];
+
+//       log_printf(TRACE,true,"SPR_access_mode::read","kernel    : %d",(int)mode._supervisor_access_mode);
+//       log_printf(TRACE,true,"SPR_access_mode::read","user      : %d",(int)mode._supervisor_access_mode);
 
       return (((SM == 1) and ( (mode._supervisor_access_mode == SPR_ACCESS_MODE_READ_ONLY     ) or
@@ -28,5 +37,5 @@
   bool SPR_access_mode::write(spr_address_t address, Tcontrol_t SM, Tcontrol_t SUMRA)
     {
-      if (not valid(address))
+      if (not exist(address))
 	return false;
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Signal_link.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Signal_link.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Signal_link.cpp	(revision 88)
@@ -51,5 +51,5 @@
 //     if (destination_have_multi_producer)
 // //       throw (ERRORMORPHEO (FUNCTION,"Signal \""+_name+"\" can't been linked with signal \""+signal_dest->get_name()+"\" : destination have multi producer."));
-//       log_printf(NONE,Behavioural,FUNCTION,"Signal \"%s\" can't been linked with signal \"%s\" : destination have multi producer.",_name.c_str(),signal_dest->get_name().c_str());
+//       log_printf(INFO,Behavioural,FUNCTION,"Signal \"%s\" can't been linked with signal \"%s\" : destination have multi producer.",_name.c_str(),signal_dest->get_name().c_str());
 
     // update info source
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Signal_test_map.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Signal_test_map.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Signal_test_map.cpp	(revision 88)
@@ -19,13 +19,13 @@
 
     std::string str     = "";
-    std::string tab     = std::string(depth,'\t');
+    std::string tab     = std::string(depth,' ');
     bool        _return = true;
 
-//     log_printf(NONE,Behavioural,FUNCTION, "%s* Signal \"%s\"",tab.c_str(),_name.c_str());
-//     log_printf(NONE,Behavioural,FUNCTION, "%s%d - %d - %d",tab.c_str(),
+//     log_printf(INFO,Behavioural,FUNCTION, "%s* Signal \"%s\"",tab.c_str(),_name.c_str());
+//     log_printf(INFO,Behavioural,FUNCTION, "%s%d - %d - %d",tab.c_str(),
 // 	       _is_map_as_toplevel_dest,
 // 	       _is_map_as_component_src,
 // 	       _is_map_as_component_dest);
-//     log_printf(NONE,Behavioural,FUNCTION, "%stop_level %d, is_behavioural %d",tab.c_str(),
+//     log_printf(INFO,Behavioural,FUNCTION, "%stop_level %d, is_behavioural %d",tab.c_str(),
 // 	       top_level,
 // 	       is_behavioural);
@@ -143,13 +143,13 @@
     if (_return == false)
       {
-	log_printf(NONE,Behavioural,FUNCTION, "%s* %s",tab.c_str(),str.c_str());
-	
 #ifndef DEBUG
 	std::cerr << str << std::endl;
+#else
+	log_printf(INFO,Interface,FUNCTION, "%s* %s",tab.c_str(),str.c_str());
 #endif
       }
     else
       {
-// 	log_printf(NONE,Behavioural,FUNCTION, "%s* Signal \"%s\" is OK.",tab.c_str(),_name.c_str());
+// 	log_printf(INFO,Interface,FUNCTION, "%s* Signal \"%s\" is OK.",tab.c_str(),_name.c_str());
       }
 
@@ -173,5 +173,5 @@
 //     if (_return == false)
 //       {
-// 	log_printf(NONE,Behavioural,FUNCTION, "%s* %s",tab.c_str(),str.c_str());
+// 	log_printf(INFO,Behavioural,FUNCTION, "%s* %s",tab.c_str(),str.c_str());
 	
 // #ifndef DEBUG
@@ -181,5 +181,5 @@
 //     else
 //       {
-// // 	log_printf(NONE,Behavioural,FUNCTION, "%s* Signal \"%s\" is OK.",tab.c_str(),_name.c_str());
+// // 	log_printf(INFO,Behavioural,FUNCTION, "%s* Signal \"%s\" is OK.",tab.c_str(),_name.c_str());
 //       }
     
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Simulation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Simulation.cpp	(revision 88)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Simulation.cpp	(revision 88)
@@ -0,0 +1,69 @@
+#ifdef SYSTEMC
+/*
+ * $Id$
+ *
+ * [ Description ]
+ * 
+ */
+
+#include "Behavioural/include/Simulation.h"
+#include "Common/include/ErrorMorpheo.h"
+
+namespace morpheo              {
+namespace behavioural          {
+
+  static bool            simulation_initialized;
+//   static uint32_t       _simulation_num_context_next;
+  double                _simulation_nb_cycle;
+//   double                _simulation_nb_instruction;
+//   std::vector<double> * _simulation_nb_instruction_commited;
+
+//   Simulation::Simulation (void):
+//     _num_context (_simulation_num_context_next)
+//   {
+//     // Test if is first context create
+//     if (_simulation_num_context_next == 0)
+//       _simulation_nb_instruction_commited = new std::vector<double>;
+
+//     _simulation_num_context_next ++;
+//   }
+  
+//   Simulation::~Simulation (void)
+//   {
+//     _simulation_num_context_next --;
+    
+//     // Test if is last context destroy
+//     if (_simulation_num_context_next == 0)
+//       delete _simulation_nb_instruction_commited;
+//   }
+
+  void simulation_init (double nb_cycle,
+                        double nb_instruction)
+  {
+    if (not simulation_initialized)
+      {
+//         _simulation_num_context_next = 0;
+        _simulation_nb_cycle         = nb_cycle       ;
+//         _simulation_nb_instruction   = nb_instruction;
+
+        if (nb_instruction != 0)
+          throw ERRORMORPHEO("simulation_init",_("Stop Condition on number instruction is not yet implemented"));
+        
+        simulation_initialized = true;
+      }
+    else
+      {
+        msg_printf(WARNING,_("Multi instance of Morpheo : stop condition, take the highest."));
+
+        if (_simulation_nb_cycle < nb_cycle)
+          _simulation_nb_cycle = nb_cycle;
+
+//         if (_simulation_nb_instruction < nb_instruction)
+//           _simulation_nb_instruction = nb_instruction;
+      }
+  }
+    
+}; // end namespace behavioural          
+}; // end namespace morpheo              
+
+#endif
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Simulation_end_cycle.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Simulation_end_cycle.cpp	(revision 88)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Simulation_end_cycle.cpp	(revision 88)
@@ -0,0 +1,23 @@
+#ifdef SYSTEMC
+/*
+ * $Id$
+ *
+ * [ Description ]
+ * 
+ */
+
+#include "Behavioural/include/Simulation.h"
+
+namespace morpheo              {
+namespace behavioural          {
+
+//   void Simulation::end_cycle (double nb_instruction_commited)
+//   {
+//     // must test if _simulation_nb_instruction_commited is allocate
+//     (*_simulation_nb_instruction_commited) [_num_context] += nb_instruction_commited;
+//   }
+
+}; // end namespace behavioural          
+}; // end namespace morpheo              
+
+#endif
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Simulation_test_end.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Simulation_test_end.cpp	(revision 88)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Simulation_test_end.cpp	(revision 88)
@@ -0,0 +1,49 @@
+#ifdef SYSTEMC
+/*
+ * $Id$
+ *
+ * [ Description ]
+ * 
+ */
+
+#include "Behavioural/include/Simulation.h"
+
+namespace morpheo              {
+namespace behavioural          {
+
+  bool simulation_test_end (void)
+  {
+    msg("##########[ cycle %d ]\n",static_cast<uint32_t>(sc_simulation_time()));
+
+    // Test if a stop condition is activate
+    if ((_simulation_nb_cycle == 0)//  and
+//         (_simulation_nb_instruction == 0)
+        )
+      return false;
+
+    bool end_cycle = true;
+//     bool end_inst  = true;
+
+    if (_simulation_nb_cycle != 0)
+      end_cycle = (_simulation_nb_cycle <= sc_simulation_time());
+
+//     if (_simulation_nb_instruction != 0)
+//       {
+//         std::vector<double>::iterator it=_simulation_nb_instruction_commited->begin();
+        
+//         // Scan all context and test if all can finish
+//         while (end_inst and it!=_simulation_nb_instruction_commited->end())
+//           {
+//             end_inst &= (*it <= _simulation_nb_instruction);
+//             it ++;
+//           }
+//       }
+    
+    return end_cycle // and end_inst
+      ;
+  }
+
+}; // end namespace behavioural          
+}; // end namespace morpheo              
+
+#endif
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_binary_tree.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_binary_tree.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_binary_tree.cpp	(revision 88)
@@ -21,41 +21,41 @@
   Stat_binary_tree:: Stat_binary_tree (counter_t   cst)
   {
-    _root  = NULL;
-    _left  = NULL;
-    _right = NULL;
+    _root      = NULL;
+    _left      = NULL;
+    _right     = NULL;
+    _data_type = NONE;
 
-    data_t data;
-    data.cst = cst;
-    _data_type   = CONSTANT;
-    _data        = data;
-
-//     Stat_binary_tree(CONSTANT, data);
+    change_type (cst);
   }
   
   Stat_binary_tree:: Stat_binary_tree (counter_t * var)
   {
-    _root  = NULL;
-    _left  = NULL;
-    _right = NULL;
+    _root      = NULL;
+    _left      = NULL;
+    _right     = NULL;
+    _data_type = NONE;
 
-    data_t data;
-    data.var   = var;
-    _data_type = VARIABLE;
-    _data      = data;
-
-//     Stat_binary_tree(VARIABLE, data);
+    change_type (var);
   }
 
   Stat_binary_tree:: Stat_binary_tree (operator_t  op)
   {
-    _root  = NULL;
-    _left  = NULL;
-    _right = NULL;
+    _root      = NULL;
+    _left      = NULL;
+    _right     = NULL;
+    _data_type = NONE;
 
-    data_t data;
-    data.op    = op;
-    _data_type = ((op == inc) or (op == dec))?OPERATOR_UNARY:OPERATOR_BINARY;
-    _data      = data;
+    change_type (op);
+  }
 
+  Stat_binary_tree:: Stat_binary_tree (std::string expr,
+                                       std::map<std::string, counter_t*> * operand)
+  {
+    _root      = NULL;
+    _left      = NULL;
+    _right     = NULL;
+    _data_type = NONE;
+
+    import (expr, operand);
   }
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_binary_tree_change_type.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_binary_tree_change_type.cpp	(revision 88)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_binary_tree_change_type.cpp	(revision 88)
@@ -0,0 +1,35 @@
+#ifdef STATISTICS
+#include "Behavioural/include/Stat_binary_tree.h"
+
+namespace morpheo {
+namespace behavioural {
+
+  void Stat_binary_tree::change_type (counter_t   cst)
+  {
+    if (_data_type != NONE)
+      throw (ERRORMORPHEO("Stat_binary_tree::change_type",_("To change type, data_type must be \'NONE\'.\n")));
+
+    _data_type = CONSTANT;
+    _data.cst  = cst;
+  }
+
+  void Stat_binary_tree::change_type (counter_t * var)
+  {
+    if (_data_type != NONE)
+      throw (ERRORMORPHEO("Stat_binary_tree::change_type",_("To change type, data_type must be \'NONE\'.\n")));
+
+    _data_type = VARIABLE;
+    _data.var  = var;
+  }
+
+  void Stat_binary_tree::change_type (operator_t  op )
+  {
+    if (_data_type != NONE)
+      throw (ERRORMORPHEO("Stat_binary_tree::change_type",_("To change type, data_type must be \'NONE\'.\n")));
+
+    _data_type = ((op == inc) or (op == dec))?OPERATOR_UNARY:OPERATOR_BINARY;
+    _data.op   = op;
+  }
+};
+};
+#endif
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_binary_tree_import.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_binary_tree_import.cpp	(revision 88)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_binary_tree_import.cpp	(revision 88)
@@ -0,0 +1,139 @@
+#ifdef STATISTICS
+#include "Behavioural/include/Stat_binary_tree.h"
+
+namespace morpheo {
+namespace behavioural {
+
+#define string2operator(x) (x=="+")?add:((x=="-")?sub:((x=="*")?mul:((x=="/" )?div:((x=="++")?inc:dec))))
+
+  void Stat_binary_tree::import (std::string expr,
+                                 std::map<std::string, counter_t*> * operand)
+  {
+    const std::string delims  (" ");          // délimiteur : " "
+    const std::string numbers ("0123456789"); // délimiteur : " "
+    std::string::size_type index_begin, index_end;
+
+    Stat_binary_tree * tree = this;
+
+    index_begin = expr.find_first_not_of(delims);
+
+    while (index_begin != std::string::npos)
+      {
+	index_end = expr.find_first_of(delims, index_begin);
+
+	if (index_end == std::string::npos)
+	  {
+	    index_end = expr.length();
+	  }
+	
+	std::string str = expr.substr(index_begin, index_end-index_begin);
+	
+	// 3 possibilités :
+	//  * operator
+	//  * constante
+	//  * variable
+	{
+	  // Test constantes
+	  std::string::size_type index = str.find_first_not_of(numbers);
+	  if (index  == std::string::npos)
+	    {
+// 	      std::cout << " * c'est une constante." << std::endl; 
+              counter_t cst = atoi(str.c_str());
+
+              if (tree->_data_type == NONE)
+                change_type(cst);
+              else
+                if (tree==NULL)
+                  tree = new Stat_binary_tree (cst);
+                else
+                  tree = tree->insert_tree (cst);
+	    }
+	  else
+	    {
+	      // Test variables
+              std::map<std::string, counter_t*>::iterator it = operand->find(str);
+	      if (it != operand->end())
+		{
+// 		  std::cout << " * c'est une variable." << std::endl; 
+                  counter_t * var = it->second;
+
+                  if (tree->_data_type == NONE)
+                    change_type(var);
+                  else
+                    if (tree==NULL)
+                      tree = new Stat_binary_tree (var);
+                    else
+                      tree = tree->insert_tree (var);
+		}
+	      else
+		{
+		  if ((str == "+") or
+		      (str == "-") or
+		      (str == "*") or
+		      (str == "/"))
+		    {
+// 		      std::cout << " * c'est un operator à 2 opérandes." << std::endl; 
+		 
+                      operator_t op = string2operator(str);
+
+                      if (tree->_data_type == NONE)
+                        change_type(op);
+                      else
+                        if (tree==NULL)
+                          tree = new Stat_binary_tree (op);
+                        else
+                          tree = tree->insert_tree (op);
+		    }
+		  else
+		    {
+		      if ((str == "++") or
+			  (str == "--"))
+			{
+// 			  std::cout << " * c'est un operator à 1 opérande." << std::endl; 
+
+                          operator_t op = string2operator(str);
+                          
+                          if (tree->_data_type == NONE)
+                            change_type(op);
+                          else
+                            if (tree==NULL)
+                              tree = new Stat_binary_tree (op);
+                            else
+                              tree = tree->insert_tree (op);
+			}
+		      else
+			{
+// 			  std::cout << " * c'est autre chose." << std::endl; 
+			  throw(ERRORMORPHEO("Stat_binary_tree::string2tree",toString(_("expression '%s' doesn't a constant, a declarated variable or an operator.\n"),str.c_str())));
+			}
+		    }
+		}
+	    }
+	}
+
+	index_begin = expr.find_first_not_of(delims, index_end);
+
+	if (index_begin != std::string::npos)
+	  tree = tree->goto_next_root();
+      }
+
+    if (tree == NULL)
+      throw (ERRORMORPHEO("Stat_binary_tree::string2tree",_("The tree generated is empty.\n")));
+
+//     std::cout << "<Stat::string2tree> goto_top_level" << std::endl;
+
+    tree = tree->goto_top_level();
+
+//     std::cout << "<Stat::string2tree> valid" << std::endl;
+
+//     print();
+
+    if ((not tree->valid()) or (not valid()))
+      throw (ERRORMORPHEO("Stat_binary_tree::string2tree",_("the tree generated is invalid.\n")));
+
+//     std::cout << "<Stat::string2tree> End" << std::endl;
+  }
+  
+};
+};
+#endif
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_binary_tree_valid.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_binary_tree_valid.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_binary_tree_valid.cpp	(revision 88)
@@ -4,24 +4,90 @@
 namespace morpheo {
 namespace behavioural {
+
   bool Stat_binary_tree::valid (void)
   {
+    if (_data_type == NONE)
+      return false;
+
     if ((_data_type == VARIABLE) or
 	(_data_type == CONSTANT))
       return ((_left  == NULL) and
-	      (_right == NULL) );
-
+              (_right == NULL) );
+    
     if (_data_type == OPERATOR_UNARY)
       return ((_right == NULL) and
-	      (_left  != NULL) and
-	      (_left->valid()));
+              (_left  != NULL) and
+              (_left->valid()));
 
     if (_data_type == OPERATOR_BINARY)
       return ((_left  != NULL ) and
-	      (_left ->valid()) and
-	      (_right != NULL ) and
-	      (_right->valid()));
+              (_left ->valid()) and
+              (_right != NULL ) and
+              (_right->valid()));
 
     return false;
   }
+
+  void Stat_binary_tree::print (uint32_t depth)
+  {
+    std::string tab = std::string(depth,'\t');
+    std::string sep = " ";
+    if (_data_type == NONE)
+      {
+        std::cout << tab << "<node> NONE (error)" << std::endl;
+
+        if (_left  != NULL)
+          _left ->print(depth+1);
+        if (_right != NULL)
+          _right->print(depth+1);
+      }
+
+    if ((_data_type == VARIABLE) or
+	(_data_type == CONSTANT))
+      {
+        std::cout << tab << "<leaf>"
+                  << " "
+                  << ((_left   == NULL)?"left  == NULL        ":"left  != NULL (error)")
+                  << " "
+                  << ((_right  == NULL)?"right == NULL        ":"right != NULL (error)")
+                  << std::endl;
+
+        if (_left  != NULL)
+          _left ->print(depth+1);
+        if (_right != NULL)
+          _right->print(depth+1);
+      }
+    
+    if (_data_type == OPERATOR_UNARY)
+      {
+        std::cout << tab << "<unary>"
+                  << " "
+                  << ((_left   == NULL)?"left  == NULL (error)":"left  != NULL        ")
+                  << " "
+                  << ((_right  == NULL)?"right == NULL        ":"right != NULL (error)")
+                  << std::endl;
+        
+        if (_left  != NULL)
+          _left ->print(depth+1);
+        if (_right != NULL)
+          _right->print(depth+1);
+      }
+
+    if (_data_type == OPERATOR_BINARY)
+      {
+        std::cout << tab << "<binary>"
+                  << " "
+                  << ((_left   == NULL)?"left  == NULL (error)":"left  != NULL        ")
+                  << " "
+                  << ((_right  == NULL)?"right == NULL (error)":"right != NULL        ")
+                  << std::endl;
+
+        if (_left  != NULL)
+          _left ->print(depth+1);
+        if (_right != NULL)
+          _right->print(depth+1);
+      }
+  }
+
 };
 };
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_generate_file.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_generate_file.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_generate_file.cpp	(revision 88)
@@ -2,4 +2,5 @@
 #include "Behavioural/include/Stat.h"
 #include "Behavioural/include/Version.h"
+#include "Common/include/Environment.h"
 
 namespace morpheo {
@@ -8,4 +9,6 @@
   void Stat::generate_file (void)
   {
+    directory();
+
     std::string body = print(1);
 
@@ -26,6 +29,6 @@
     xml->balise_close();
 
-    xml->filename_extension ("stat");
-    xml->generate_file();
+    xml->filename_extension (".stat");
+    xml->generate_file(MORPHEO_STATISTICS);
 
     delete xml;
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_have_counter.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_have_counter.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_have_counter.cpp	(revision 88)
@@ -10,7 +10,8 @@
 	 i!= _list_operand->end();
 	 ++i)
-      if (i->second.type == TYPE_COUNTER)
-	return true;
-
+      {
+        if (i->second.type == TYPE_COUNTER)
+          return true;
+      }
     return false;
   }
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_print.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_print.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_print.cpp	(revision 88)
@@ -7,4 +7,7 @@
   std::string Stat::print (uint32_t depth)
   {
+//     log_printf(TRACE,Behavioural,"Stat::print","Component name : %s",_name_component.c_str());
+//     log_printf(TRACE,Behavioural,"Stat::print","Instance  name : %s",_name_instance .c_str());
+
     end_simulation(); 
 
@@ -21,6 +24,7 @@
 	 stat != _list_stat->end();
 	 stat ++)
-      xml.text((*stat)->print(1));
-    
+      {
+        xml.text((*stat)->print(1));
+      }
 
     // Test special case
@@ -63,5 +67,5 @@
 		     ++operand)
 		  {
-		    if (operand->second.type == TYPE_COUNTER)
+ 		    if (operand->second.type == TYPE_COUNTER)
 		      {
 			xml.singleton_begin(operand->second.name);
@@ -80,6 +84,7 @@
 	  }
       }
+    
     xml.balise_close();
-
+    
     return xml.get_body(depth);
   }
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_string2tree.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_string2tree.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_string2tree.cpp	(revision 88)
@@ -5,125 +5,18 @@
 namespace behavioural {
 
-#define string2operator(x) (x=="+")?add:((x=="-")?sub:((x=="*")?mul:((x=="/" )?div:((x=="++")?inc:dec))))
-
   Stat_binary_tree * Stat::string2tree     (std::string expr)
   {
-    const std::string delims  (" ");          // délimiteur : " "
-    const std::string numbers ("0123456789"); // délimiteur : " "
-    std::string::size_type index_begin, index_end;
+    std::map<std::string, counter_t*> * operand = new std::map<std::string, counter_t*>;
 
-    Stat_binary_tree * tree = NULL;
+    for (std::map<std::string, var_t>::iterator it = _list_operand->begin();
+         it != _list_operand->end();
+         ++ it)
+      (*operand) [it->first] = it->second.counter;
 
-    index_begin = expr.find_first_not_of(delims);
+    Stat_binary_tree * tree = new Stat_binary_tree(expr,operand);
 
-    while (index_begin != std::string::npos)
-      {
-	index_end = expr.find_first_of(delims, index_begin);
-
-	if (index_end == std::string::npos)
-	  {
-	    index_end = expr.length();
-	  }
-	
-	std::string str = expr.substr(index_begin, index_end-index_begin);
-	
-	// 3 possibilités :
-	//  * operator
-	//  * constante
-	//  * variable
-	{
-	  // Test constantes
-	  std::string::size_type index = str.find_first_not_of(numbers);
-	  if (index  == std::string::npos)
-	    {
-// 	      std::cout << " * c'est une constante." << std::endl; 
-
-	      if (tree==NULL)
-		tree = new Stat_binary_tree (atoi(str.c_str()));
-	      else
-		tree = tree->insert_tree (atoi(str.c_str()));
-	    }
-	  else
-	    {
-	      // Test variables
-	      std::map<std::string, var_t>::iterator it = _list_operand->find(str);
-	      if (it != _list_operand->end())
-		{
-// 		  std::cout << " * c'est une variable." << std::endl; 
-
-		  if (tree==NULL)
-		    tree = new Stat_binary_tree (it->second.counter);
-		  else
-		    tree = tree->insert_tree (it->second.counter);
-		}
-	      else
-		{
-		  if ((str == "+") or
-		      (str == "-") or
-		      (str == "*") or
-		      (str == "/"))
-		    {
-// 		      std::cout << " * c'est un operator à 2 opérandes." << std::endl; 
-		      
-// 		      if (tree==NULL)
-// 			tree = new Stat_binary_tree (morpheo::string2operator[str].second);
-// 		      else
-// 			tree->insert_tree (morpheo::string2operator[str].second);
-		      if (tree==NULL)
-			tree = new Stat_binary_tree (string2operator(str));
-		      else
-			tree = tree->insert_tree (string2operator(str));
-		    }
-		  else
-		    {
-		      if ((str == "++") or
-			  (str == "--"))
-			{
-// 			  std::cout << " * c'est un operator à 1 opérande." << std::endl; 
-
-// 			  if (tree==NULL)
-// 			    tree = new Stat_binary_tree (string2operator[str.c_str()]);
-// 			  else
-// 			    tree->insert_tree (string2operator[str.c_str()]);
-
-			  if (tree==NULL)
-			    tree = new Stat_binary_tree (string2operator(str));
-			  else
-			    tree = tree->insert_tree (string2operator(str));
-			  
-			}
-		      else
-			{
-// 			  std::cout << " * c'est autre chose." << std::endl; 
-			  str = "expression '"+str+"' doesn't a constant, a declarated variable or an operator.";
-			  throw(ERRORMORPHEO("Stat::string2tree",_(str.c_str())));
-			}
-		    }
-		}
-	    }
-	}
-
-	index_begin = expr.find_first_not_of(delims, index_end);
-
-	if (index_begin != std::string::npos)
-	  tree = tree->goto_next_root();
-      }
-
-    if (tree == NULL)
-      throw (ERRORMORPHEO("Stat::string2tree",_("the tree generated is empty.")));
-
-//     std::cout << "<Stat::string2tree> goto_top_level" << std::endl;
-
-    tree = tree->goto_top_level();
-
-//     std::cout << "<Stat::string2tree> valid" << std::endl;
-
-    if (not tree->valid())
-      throw (ERRORMORPHEO("Stat::string2tree",_("the tree generated is invalid.")));
-
-//     std::cout << "<Stat::string2tree> End" << std::endl;
+    delete operand;
 
     return tree;
-
   }
   
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Types.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Types.cpp	(revision 88)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Types.cpp	(revision 88)
@@ -0,0 +1,258 @@
+/*
+ * $Id$
+ *
+ * [ Description ]
+ * 
+ */
+
+#include "Behavioural/include/Types.h"
+#include "Common/include/Translation.h"
+
+namespace morpheo {
+namespace behavioural {
+
+#undef  FUNCTION
+#define FUNCTION "instruction_information"
+  instruction_t instruction_information (uint32_t instruction)
+  {
+    switch (instruction)
+      {
+      case INSTRUCTION_L_ADD       : return instruction_t (TYPE_ALU    ,OPERATION_ALU_L_ADD             ,ORBIS32,1);
+      case INSTRUCTION_L_ADDC      : return instruction_t (TYPE_ALU    ,OPERATION_ALU_L_ADD             ,ORBIS32,1);
+      case INSTRUCTION_L_ADDI      : return instruction_t (TYPE_ALU    ,OPERATION_ALU_L_ADD             ,ORBIS32,1);
+      case INSTRUCTION_L_ADDIC     : return instruction_t (TYPE_ALU    ,OPERATION_ALU_L_ADD             ,ORBIS32,1);
+      case INSTRUCTION_L_AND       : return instruction_t (TYPE_ALU    ,OPERATION_ALU_L_AND             ,ORBIS32,1);
+      case INSTRUCTION_L_ANDI      : return instruction_t (TYPE_ALU    ,OPERATION_ALU_L_AND             ,ORBIS32,1);
+      case INSTRUCTION_L_BF        : return instruction_t (TYPE_BRANCH ,OPERATION_BRANCH_L_TEST_F       ,ORBIS32,1);
+      case INSTRUCTION_L_BNF       : return instruction_t (TYPE_BRANCH ,OPERATION_BRANCH_L_TEST_NF      ,ORBIS32,1);
+      case INSTRUCTION_L_CMOV      : return instruction_t (TYPE_MOVE   ,OPERATION_MOVE_L_CMOV           ,ORBIS32,2);
+      case INSTRUCTION_L_CSYNC     : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_CSYNC       ,ORBIS32,2);
+      case INSTRUCTION_L_CUST1     : return instruction_t (TYPE_CUSTOM ,OPERATION_CUSTOM_L_1            ,ORBIS32,2);
+      case INSTRUCTION_L_CUST2     : return instruction_t (TYPE_CUSTOM ,OPERATION_CUSTOM_L_2            ,ORBIS32,2);
+      case INSTRUCTION_L_CUST3     : return instruction_t (TYPE_CUSTOM ,OPERATION_CUSTOM_L_3            ,ORBIS32,2);
+      case INSTRUCTION_L_CUST4     : return instruction_t (TYPE_CUSTOM ,OPERATION_CUSTOM_L_4            ,ORBIS32,2);
+      case INSTRUCTION_L_CUST5     : return instruction_t (TYPE_CUSTOM ,OPERATION_CUSTOM_L_5            ,ORBIS32,2);
+      case INSTRUCTION_L_CUST6     : return instruction_t (TYPE_CUSTOM ,OPERATION_CUSTOM_L_6            ,ORBIS32,2);
+      case INSTRUCTION_L_CUST7     : return instruction_t (TYPE_CUSTOM ,OPERATION_CUSTOM_L_7            ,ORBIS32,2);
+      case INSTRUCTION_L_CUST8     : return instruction_t (TYPE_CUSTOM ,OPERATION_CUSTOM_L_8            ,ORBIS32,2);
+      case INSTRUCTION_L_DIV       : return instruction_t (TYPE_DIV    ,OPERATION_DIV_L_DIV             ,ORBIS32,2);
+      case INSTRUCTION_L_DIVU      : return instruction_t (TYPE_DIV    ,OPERATION_DIV_L_DIVU            ,ORBIS32,2);
+      case INSTRUCTION_L_EXTBS     : return instruction_t (TYPE_EXTEND ,OPERATION_EXTEND_L_EXTEND_S     ,ORBIS32,2);
+      case INSTRUCTION_L_EXTBZ     : return instruction_t (TYPE_EXTEND ,OPERATION_EXTEND_L_EXTEND_Z     ,ORBIS32,2);
+      case INSTRUCTION_L_EXTHS     : return instruction_t (TYPE_EXTEND ,OPERATION_EXTEND_L_EXTEND_S     ,ORBIS32,2);
+      case INSTRUCTION_L_EXTHZ     : return instruction_t (TYPE_EXTEND ,OPERATION_EXTEND_L_EXTEND_Z     ,ORBIS32,2);
+      case INSTRUCTION_L_EXTWS     : return instruction_t (TYPE_EXTEND ,OPERATION_EXTEND_L_EXTEND_S     ,ORBIS64,2);
+      case INSTRUCTION_L_EXTWZ     : return instruction_t (TYPE_EXTEND ,OPERATION_EXTEND_L_EXTEND_Z     ,ORBIS64,2);
+      case INSTRUCTION_L_FF1       : return instruction_t (TYPE_FIND   ,OPERATION_FIND_L_FF1            ,ORBIS32,2);
+      case INSTRUCTION_L_FL1       : return instruction_t (TYPE_FIND   ,OPERATION_FIND_L_FL1            ,ORBIS32,2);
+      case INSTRUCTION_L_J         : return instruction_t (TYPE_BRANCH ,OPERATION_BRANCH_NONE           ,ORBIS32,1);
+      case INSTRUCTION_L_JAL       : return instruction_t (TYPE_BRANCH ,OPERATION_BRANCH_L_JALR         ,ORBIS32,1);
+      case INSTRUCTION_L_JALR      : return instruction_t (TYPE_BRANCH ,OPERATION_BRANCH_L_JALR         ,ORBIS32,1);
+      case INSTRUCTION_L_JR        : return instruction_t (TYPE_BRANCH ,OPERATION_BRANCH_L_JALR         ,ORBIS32,1);
+      case INSTRUCTION_L_LBS       : return instruction_t (TYPE_MEMORY ,OPERATION_MEMORY_LOAD_8_S       ,ORBIS32,1);
+      case INSTRUCTION_L_LBZ       : return instruction_t (TYPE_MEMORY ,OPERATION_MEMORY_LOAD_8_Z       ,ORBIS32,1);
+      case INSTRUCTION_L_LD        : return instruction_t (TYPE_MEMORY ,OPERATION_MEMORY_LOAD_64_S      ,ORBIS64,1);
+      case INSTRUCTION_L_LHS       : return instruction_t (TYPE_MEMORY ,OPERATION_MEMORY_LOAD_16_S      ,ORBIS32,1);
+      case INSTRUCTION_L_LHZ       : return instruction_t (TYPE_MEMORY ,OPERATION_MEMORY_LOAD_16_Z      ,ORBIS32,1);
+      case INSTRUCTION_L_LWS       : return instruction_t (TYPE_MEMORY ,OPERATION_MEMORY_LOAD_32_S      ,ORBIS32,1);
+      case INSTRUCTION_L_LWZ       : return instruction_t (TYPE_MEMORY ,OPERATION_MEMORY_LOAD_32_Z      ,ORBIS32,1);
+      case INSTRUCTION_L_MAC       : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_MAC         ,ORBIS32,2);
+      case INSTRUCTION_L_MACI      : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_MAC         ,ORBIS32,2);
+      case INSTRUCTION_L_MACRC     : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_MACRC       ,ORBIS32,2);
+      case INSTRUCTION_L_MFSPR     : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_MFSPR       ,ORBIS32,1);
+      case INSTRUCTION_L_MOVHI     : return instruction_t (TYPE_MOVE   ,OPERATION_MOVE_L_MOVHI          ,ORBIS32,1);
+      case INSTRUCTION_L_MSB       : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_MSB         ,ORBIS32,2);
+      case INSTRUCTION_L_MSYNC     : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_MSYNC       ,ORBIS32,2);
+      case INSTRUCTION_L_MTSPR     : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_MTSPR       ,ORBIS32,1);
+      case INSTRUCTION_L_MUL       : return instruction_t (TYPE_MUL    ,OPERATION_MUL_L_MUL             ,ORBIS32,1);
+      case INSTRUCTION_L_MULI      : return instruction_t (TYPE_MUL    ,OPERATION_MUL_L_MUL             ,ORBIS32,1);
+      case INSTRUCTION_L_MULU      : return instruction_t (TYPE_MUL    ,OPERATION_MUL_L_MULU            ,ORBIS32,1);
+      case INSTRUCTION_L_NOP       : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORBIS32,1);
+      case INSTRUCTION_L_OR        : return instruction_t (TYPE_ALU    ,OPERATION_ALU_L_OR              ,ORBIS32,1);
+      case INSTRUCTION_L_ORI       : return instruction_t (TYPE_ALU    ,OPERATION_ALU_L_OR              ,ORBIS32,1);
+      case INSTRUCTION_L_PSYNC     : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_PSYNC       ,ORBIS32,2);
+      case INSTRUCTION_L_RFE       : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_RFE         ,ORBIS32,1);
+      case INSTRUCTION_L_ROR       : return instruction_t (TYPE_SHIFT  ,OPERATION_SHIFT_L_ROR           ,ORBIS32,2);
+      case INSTRUCTION_L_RORI      : return instruction_t (TYPE_SHIFT  ,OPERATION_SHIFT_L_ROR           ,ORBIS32,2);
+      case INSTRUCTION_L_SB        : return instruction_t (TYPE_MEMORY ,OPERATION_MEMORY_STORE_8        ,ORBIS32,1);
+      case INSTRUCTION_L_SD        : return instruction_t (TYPE_MEMORY ,OPERATION_MEMORY_STORE_64       ,ORBIS64,1);
+      case INSTRUCTION_L_SFEQ      : return instruction_t (TYPE_TEST   ,OPERATION_TEST_L_SFEQ           ,ORBIS32,1);
+      case INSTRUCTION_L_SFEQI     : return instruction_t (TYPE_TEST   ,OPERATION_TEST_L_SFEQ           ,ORBIS32,1);
+      case INSTRUCTION_L_SFGES     : return instruction_t (TYPE_TEST   ,OPERATION_TEST_L_SFGES          ,ORBIS32,1);
+      case INSTRUCTION_L_SFGESI    : return instruction_t (TYPE_TEST   ,OPERATION_TEST_L_SFGES          ,ORBIS32,2);
+      case INSTRUCTION_L_SFGEU     : return instruction_t (TYPE_TEST   ,OPERATION_TEST_L_SFGEU          ,ORBIS32,1);
+      case INSTRUCTION_L_SFGEUI    : return instruction_t (TYPE_TEST   ,OPERATION_TEST_L_SFGEU          ,ORBIS32,2);
+      case INSTRUCTION_L_SFGTS     : return instruction_t (TYPE_TEST   ,OPERATION_TEST_L_SFGTS          ,ORBIS32,1);
+      case INSTRUCTION_L_SFGTSI    : return instruction_t (TYPE_TEST   ,OPERATION_TEST_L_SFGTS          ,ORBIS32,2);
+      case INSTRUCTION_L_SFGTU     : return instruction_t (TYPE_TEST   ,OPERATION_TEST_L_SFGTU          ,ORBIS32,1);
+      case INSTRUCTION_L_SFGTUI    : return instruction_t (TYPE_TEST   ,OPERATION_TEST_L_SFGTU          ,ORBIS32,2);
+      case INSTRUCTION_L_SFLES     : return instruction_t (TYPE_TEST   ,OPERATION_TEST_L_SFLES          ,ORBIS32,1);
+      case INSTRUCTION_L_SFLESI    : return instruction_t (TYPE_TEST   ,OPERATION_TEST_L_SFLES          ,ORBIS32,2);
+      case INSTRUCTION_L_SFLEU     : return instruction_t (TYPE_TEST   ,OPERATION_TEST_L_SFLEU          ,ORBIS32,1);
+      case INSTRUCTION_L_SFLEUI    : return instruction_t (TYPE_TEST   ,OPERATION_TEST_L_SFLEU          ,ORBIS32,2);
+      case INSTRUCTION_L_SFLTS     : return instruction_t (TYPE_TEST   ,OPERATION_TEST_L_SFLTS          ,ORBIS32,1);
+      case INSTRUCTION_L_SFLTSI    : return instruction_t (TYPE_TEST   ,OPERATION_TEST_L_SFLTS          ,ORBIS32,2);
+      case INSTRUCTION_L_SFLTU     : return instruction_t (TYPE_TEST   ,OPERATION_TEST_L_SFLTU          ,ORBIS32,1);
+      case INSTRUCTION_L_SFLTUI    : return instruction_t (TYPE_TEST   ,OPERATION_TEST_L_SFLTU          ,ORBIS32,2);
+      case INSTRUCTION_L_SFNE      : return instruction_t (TYPE_TEST   ,OPERATION_TEST_L_SFNE           ,ORBIS32,1);
+      case INSTRUCTION_L_SFNEI     : return instruction_t (TYPE_TEST   ,OPERATION_TEST_L_SFNE           ,ORBIS32,2);
+      case INSTRUCTION_L_SH        : return instruction_t (TYPE_MEMORY ,OPERATION_MEMORY_STORE_16       ,ORBIS32,1);
+      case INSTRUCTION_L_SLL       : return instruction_t (TYPE_SHIFT  ,OPERATION_SHIFT_L_SLL           ,ORBIS32,1);
+      case INSTRUCTION_L_SLLI      : return instruction_t (TYPE_SHIFT  ,OPERATION_SHIFT_L_SLL           ,ORBIS32,1);
+      case INSTRUCTION_L_SRA       : return instruction_t (TYPE_SHIFT  ,OPERATION_SHIFT_L_SRA           ,ORBIS32,1);
+      case INSTRUCTION_L_SRAI      : return instruction_t (TYPE_SHIFT  ,OPERATION_SHIFT_L_SRA           ,ORBIS32,1);
+      case INSTRUCTION_L_SRL       : return instruction_t (TYPE_SHIFT  ,OPERATION_SHIFT_L_SRL           ,ORBIS32,1);
+      case INSTRUCTION_L_SRLI      : return instruction_t (TYPE_SHIFT  ,OPERATION_SHIFT_L_SRL           ,ORBIS32,1);
+      case INSTRUCTION_L_SUB       : return instruction_t (TYPE_ALU    ,OPERATION_ALU_L_SUB             ,ORBIS32,1);
+      case INSTRUCTION_L_SW        : return instruction_t (TYPE_MEMORY ,OPERATION_MEMORY_STORE_32       ,ORBIS32,1);
+      case INSTRUCTION_L_SYS       : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_SYS         ,ORBIS32,1);
+      case INSTRUCTION_L_TRAP      : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_TRAP        ,ORBIS32,2);
+      case INSTRUCTION_L_XOR       : return instruction_t (TYPE_ALU    ,OPERATION_ALU_L_XOR             ,ORBIS32,1);
+      case INSTRUCTION_L_XORI      : return instruction_t (TYPE_ALU    ,OPERATION_ALU_L_XOR             ,ORBIS32,1);
+                                                                                                                       
+      case INSTRUCTION_LF_ADD_D    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX64,1);
+      case INSTRUCTION_LF_ADD_S    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX32,1);
+      case INSTRUCTION_LF_CUST1_D  : return instruction_t (TYPE_CUSTOM ,OPERATION_CUSTOM_LF_1_D         ,ORFPX64,2);
+      case INSTRUCTION_LF_CUST1_S  : return instruction_t (TYPE_CUSTOM ,OPERATION_CUSTOM_LF_1_S         ,ORFPX32,2);
+      case INSTRUCTION_LF_DIV_D    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX64,2);
+      case INSTRUCTION_LF_DIV_S    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX32,2);
+      case INSTRUCTION_LF_FTOI_D   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX64,1);
+      case INSTRUCTION_LF_FTOI_S   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX32,1);
+      case INSTRUCTION_LF_ITOF_D   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX64,1);
+      case INSTRUCTION_LF_ITOF_S   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX32,1);
+      case INSTRUCTION_LF_MADD_D   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX64,2);
+      case INSTRUCTION_LF_MADD_S   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX32,2);
+      case INSTRUCTION_LF_MUL_D    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX64,1);
+      case INSTRUCTION_LF_MUL_S    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX32,1);
+      case INSTRUCTION_LF_REM_D    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX64,2);
+      case INSTRUCTION_LF_REM_S    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX32,2);
+      case INSTRUCTION_LF_SFEQ_D   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX64,1);
+      case INSTRUCTION_LF_SFEQ_S   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX32,1);
+      case INSTRUCTION_LF_SFGE_D   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX64,1);
+      case INSTRUCTION_LF_SFGE_S   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX32,1);
+      case INSTRUCTION_LF_SFGT_D   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX64,1);
+      case INSTRUCTION_LF_SFGT_S   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX32,1);
+      case INSTRUCTION_LF_SFLE_D   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX64,1);
+      case INSTRUCTION_LF_SFLE_S   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX32,1);
+      case INSTRUCTION_LF_SFLT_D   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX64,1);
+      case INSTRUCTION_LF_SFLT_S   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX32,1);
+      case INSTRUCTION_LF_SFNE_D   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX64,1);
+      case INSTRUCTION_LF_SFNE_S   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX32,1);
+      case INSTRUCTION_LF_SUB_D    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX64,1);
+      case INSTRUCTION_LF_SUB_S    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORFPX32,1);
+                                                                                                                       
+      case INSTRUCTION_LV_ADD_B    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ADD_H    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ADDS_B   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ADDS_H   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ADDU_B   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ADDU_H   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ADDUS_B  : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ADDUS_H  : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ALL_EQ_B : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ALL_EQ_H : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ALL_GE_B : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ALL_GE_H : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ALL_GT_B : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ALL_GT_H : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ALL_LE_B : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ALL_LE_H : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ALL_LT_B : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ALL_LT_H : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ALL_NE_B : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ALL_NE_H : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_AND      : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ANY_EQ_B : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ANY_EQ_H : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ANY_GE_B : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ANY_GE_H : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ANY_GT_B : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ANY_GT_H : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ANY_LE_B : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ANY_LE_H : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ANY_LT_B : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ANY_LT_H : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ANY_NE_B : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_ANY_NE_H : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_AVG_B    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_AVG_H    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_CMP_EQ_B : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_CMP_EQ_H : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_CMP_GE_B : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_CMP_GE_H : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_CMP_GT_B : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_CMP_GT_H : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_CMP_LE_B : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_CMP_LE_H : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_CMP_LT_B : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_CMP_LT_H : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_CMP_NE_B : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_CMP_NE_H : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_CUST1    : return instruction_t (TYPE_CUSTOM ,OPERATION_CUSTOM_LV_1           ,ORVDX64,2);
+      case INSTRUCTION_LV_CUST2    : return instruction_t (TYPE_CUSTOM ,OPERATION_CUSTOM_LV_2           ,ORVDX64,2);
+      case INSTRUCTION_LV_CUST3    : return instruction_t (TYPE_CUSTOM ,OPERATION_CUSTOM_LV_3           ,ORVDX64,2);
+      case INSTRUCTION_LV_CUST4    : return instruction_t (TYPE_CUSTOM ,OPERATION_CUSTOM_LV_4           ,ORVDX64,2);
+      case INSTRUCTION_LV_MADDS_H  : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_MAX_B    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_MAX_H    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_MERGE_B  : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_MERGE_H  : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_MIN_B    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_MIN_H    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_MSUBS_H  : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_MULS_H   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,2);
+      case INSTRUCTION_LV_NAND     : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_NOR      : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_OR       : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_PACK_B   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_PACK_H   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_PACKS_B  : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_PACKS_H  : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_PACKUS_B : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_PACKUS_H : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_PERM_N   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_RL_B     : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_RL_H     : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_SLL      : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_SLL_B    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_SLL_H    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_SRA_B    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_SRA_H    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_SRL      : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_SRL_B    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_SRL_H    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_SUB_B    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_SUB_H    : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_SUBS_B   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_SUBS_H   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_SUBU_B   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_SUBU_H   : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_SUBUS_B  : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_SUBUS_H  : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_UNPACK_B : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_UNPACK_H : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+      case INSTRUCTION_LV_XOR      : return instruction_t (TYPE_SPECIAL,OPERATION_SPECIAL_L_NOP         ,ORVDX64,1);
+
+      default                      : throw (ERRORMORPHEO (FUNCTION,_("Unknow instruction")));
+      }
+  };
+
+#undef  FUNCTION
+#define FUNCTION "instruction_size_data"
+  uint32_t instruction_size_data (uint32_t instruction)
+  {
+    ISA subset = instruction_information(instruction)._isa_subset;
+
+    switch(subset)
+      {
+      case ORBIS32 :
+      case ORFPX32 : return 32;
+      case ORBIS64 :
+      case ORFPX64 :
+      case ORVDX64 : return 64;
+      default : throw (ERRORMORPHEO (FUNCTION,_("Unknow subset")));
+      }
+  }
+
+}; // end namespace behavioural
+}; // end namespace morpheo              
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Usage.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Usage.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Usage.cpp	(revision 88)
@@ -20,34 +20,35 @@
     return ((usage & flag) != 0);
   }
-
+#undef  FUNCTION
+#define FUNCTION "usage_environment"
   void     usage_environment (Tusage_t usage)
   {
 #ifndef SYSTEMC
     if (usage_is_set(usage,USE_SYSTEMC))
-      throw ErrorMorpheo(_("Component use the flag \"USE_SYSTEMC\", but the macro's compiler \"SYSTEMC\" is unset."));
+      throw ERRORMORPHEO(FUNCTION,_("Component use the flag \"USE_SYSTEMC\", but the macro's compiler \"SYSTEMC\" is unset.\n"));
 #endif
 #ifndef VHDL
     if (usage_is_set(usage,USE_VHDL))
-      throw ErrorMorpheo(_("Component use the flag \"USE_VHDL\", but the macro's compiler \"VHDL\" is unset."));
+      throw ERRORMORPHEO(FUNCTION,_("Component use the flag \"USE_VHDL\", but the macro's compiler \"VHDL\" is unset.\n"));
 #endif
 #ifndef VHDL_TESTBENCH
     if (usage_is_set(usage,USE_VHDL_TESTBENCH))
-      throw ErrorMorpheo(_("Component use the flag \"USE_VHDL_TESTBENCH\", but the macro's compiler \"VHDL_TESTBENCH\" is unset."));
+      throw ERRORMORPHEO(FUNCTION,_("Component use the flag \"USE_VHDL_TESTBENCH\", but the macro's compiler \"VHDL_TESTBENCH\" is unset.\n"));
 #endif
 #ifndef VHDL_TESTBENCH_ASSERT
     if (usage_is_set(usage,USE_VHDL_TESTBENCH_ASSERT))
-      throw ErrorMorpheo(_("Component use the flag \"USE_VHDL_TESTBENCH_ASSERT\", but the macro's compiler \"VHDL_TESTBENCH_ASSERT\" is unset."));
+      throw ERRORMORPHEO(FUNCTION,_("Component use the flag \"USE_VHDL_TESTBENCH_ASSERT\", but the macro's compiler \"VHDL_TESTBENCH_ASSERT\" is unset.\n"));
 #endif
 #ifndef POSITION
     if (usage_is_set(usage,USE_POSITION))
-      throw ErrorMorpheo(_("Component use the flag \"USE_POSITION\", but the macro's compiler \"POSITION\" is unset."));
+      throw ERRORMORPHEO(FUNCTION,_("Component use the flag \"USE_POSITION\", but the macro's compiler \"POSITION\" is unset.\n"));
 #endif
 #ifndef STATISTICS
     if (usage_is_set(usage,USE_STATISTICS))
-      throw ErrorMorpheo(_("Component use the flag \"USE_STATISTICS\", but the macro's compiler \"STATISTICS\" is unset."));
+      throw ERRORMORPHEO(FUNCTION,_("Component use the flag \"USE_STATISTICS\", but the macro's compiler \"STATISTICS\" is unset.\n"));
 #endif
 #ifndef INFORMATION
     if (usage_is_set(usage,USE_INFORMATION))
-      throw ErrorMorpheo(_("Component use the flag \"USE_INFORMATION\", but the macro's compiler \"INFORMATION\" is unset."));
+      throw ERRORMORPHEO(FUNCTION,_("Component use the flag \"USE_INFORMATION\", but the macro's compiler \"INFORMATION\" is unset.\n"));
 #endif
 
@@ -56,17 +57,17 @@
 
     if (usage_is_set(usage,USE_STATISTICS) and not usage_is_set(usage,USE_SYSTEMC))
-      throw ErrorMorpheo(_("Usage flags conflit : to use the statistics, you must set flag USE_SYSTEMC"));
+      throw ERRORMORPHEO(FUNCTION,_("Usage flags conflit : to use the statistics, you must set flag USE_SYSTEMC\n"));
     
     if (usage_is_set(usage,USE_INFORMATION) and not usage_is_set(usage,USE_STATISTICS))
-      throw ErrorMorpheo(_("Usage flags conflit : to use the information, you must set flag USE_STATISTICS"));
+      throw ERRORMORPHEO(FUNCTION,_("Usage flags conflit : to use the information, you must set flag USE_STATISTICS\n"));
     
     if (usage_is_set(usage,USE_VHDL_TESTBENCH) and not usage_is_set(usage,USE_SYSTEMC))
-      throw ErrorMorpheo(_("Usage flags conflit : to use the vhdl's test bench, you must set flag USE_SYSTEMC"));
+      throw ERRORMORPHEO(FUNCTION,_("Usage flags conflit : to use the vhdl's test bench, you must set flag USE_SYSTEMC\n"));
     
     if (usage_is_set(usage,USE_VHDL_TESTBENCH) and not usage_is_set(usage,USE_VHDL))
-      throw ErrorMorpheo(_("Usage flags conflit : to use the vhdl's test bench, you must set flag USE_VHDL"));
+      throw ERRORMORPHEO(FUNCTION,_("Usage flags conflit : to use the vhdl's test bench, you must set flag USE_VHDL\n"));
     
     if (usage_is_set(usage,USE_VHDL_TESTBENCH_ASSERT) and not usage_is_set(usage,USE_VHDL_TESTBENCH))
-      throw ErrorMorpheo(_("Usage flags conflit : to use an assert in vhdl's test bench, you must set flag USE_VHDL_TESTBENCH"));
+      throw ERRORMORPHEO(FUNCTION,_("Usage flags conflit : to use an assert in vhdl's test bench, you must set flag USE_VHDL_TESTBENCH\n"));
   }
 
@@ -96,5 +97,5 @@
     usage = usage_set(usage,USE_INFORMATION);
 #endif
-
+    usage = usage_set(usage,USE_HEADER);
 #ifdef DEBUG
 #endif
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_generate_file_model.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_generate_file_model.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_generate_file_model.cpp	(revision 88)
@@ -9,4 +9,5 @@
 
 #include "Behavioural/include/Vhdl.h"
+#include "Common/include/Environment.h"
 #include <sstream>
 #include <fstream>
@@ -19,8 +20,9 @@
     log_printf(FUNC,Behavioural,"generate_file_model","Begin");
 
-    std::string filename = _name + ".vhdl";
+    directory();
+
+    std::string filename = MORPHEO_VHDL + "/" + _name + ".vhdl";
     
-    log_printf(TRACE,Behavioural,"generate_file_model","print %s",filename.c_str());
-    std::cout << "Generate file \""<< filename << "\"" << std::endl;
+    msg_printf(INFORMATION,_("Generate file \"%s\"."),filename.c_str());
 
     log_printf(TRACE,Behavioural,"generate_file_model","declaration");
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_generate_file_package.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_generate_file_package.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_generate_file_package.cpp	(revision 88)
@@ -9,4 +9,5 @@
 
 #include "Behavioural/include/Vhdl.h"
+#include "Common/include/Environment.h"
 #include <sstream>
 #include <fstream>
@@ -19,8 +20,10 @@
     log_printf(FUNC,Behavioural,"generate_file_package","Begin");
 
+    directory();
+
     std::string name     = _name + "_Pack";
-    std::string filename =  name + ".vhdl";
+    std::string filename = MORPHEO_VHDL + "/" + name + ".vhdl";
 
-    std::cout << "Generate file \""<< filename << "\"" << std::endl;
+    msg_printf(INFORMATION,_("Generate file \"%s\"."),filename.c_str());
 
     std::ofstream file;
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_get_header.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_get_header.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_get_header.cpp	(revision 88)
@@ -32,5 +32,5 @@
     text += "-- "+toString(_("File : "))            + filename  +"\n";
     text += "-- "+toString(_("Date : "))            + ctime (&current_time );
-    text += "-- "+toString(_("Morpheo version : ")) + MORPHEO_VERSION +"\n";
+    text += "-- "+toString(_("Morpheo version : ")) + MORPHEO_HEADER +"\n";
     text += "-- "+toString(_("Comment : "))         + _("it's a autogenerated file, don't modify") +"\n";
     text += "-------------------------------------------------------------------------------\n";
@@ -38,5 +38,5 @@
     log_printf(FUNC,Behavioural,FUNCTION,"End");
 
-    return text.str();
+    return text;
   };
   
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_set_body.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_set_body.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_set_body.cpp	(revision 88)
@@ -17,8 +17,22 @@
 #undef  FUNCTION
 #define FUNCTION "Vhdl::set_body"
-  void Vhdl::set_body (std::string      text     )
+  void Vhdl::set_body (std::string text)
   {
     log_printf(FUNC,Behavioural,FUNCTION,"Begin");
     set_list(_list_body, text);
+    log_printf(FUNC,Behavioural,FUNCTION,"End");
+  };
+  
+#undef  FUNCTION
+#define FUNCTION "Vhdl::set_body"
+  void Vhdl::set_body (Vhdl * vhdl)
+  {
+    log_printf(FUNC,Behavioural,FUNCTION,"Begin");
+    
+    for (std::list<std::string>::iterator it=vhdl->_list_body.begin();
+         it!=vhdl->_list_body.end();
+         ++it)
+      set_list(_list_body, *it);
+
     log_printf(FUNC,Behavioural,FUNCTION,"End");
   };
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML.cpp	(revision 88)
@@ -17,5 +17,5 @@
   {
     log_printf(FUNC,Behavioural,FUNCTION,"Begin");
-    _filename_extension="xml";
+    _filename_extension=".xml";
     log_printf(FUNC,Behavioural,FUNCTION,"End");
   };
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XMLLightFunctors.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XMLLightFunctors.cpp	(revision 88)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XMLLightFunctors.cpp	(revision 88)
@@ -0,0 +1,42 @@
+#include "Behavioural/include/XMLLightFunctors.h"
+
+using namespace morpheo::XMLUtils; 
+using namespace std;
+
+	//****************************XMLLightComparator method implementation*****************************//
+	
+		// the comparator functor used within parsing algorithm.
+
+		bool XMLLightComparator::operator() ( char firstChar, char secondChar ) {
+			static unsigned int counter = 0; 
+			static bool  searchForEndTag = false;
+
+			if ( searchForEndTag ) {
+				if ( secondChar == END_TAG ) {
+					searchForEndTag = false;
+					return true;
+				}
+				return false;
+			}
+
+			if   
+			( ( firstChar == BEGIN_TAG && secondChar == SECOND_TAG ) ||
+	     		( firstChar == SECOND_TAG && secondChar == END_TAG ) ) {
+				 --counter;
+				if ( ! counter ) {
+					if( firstChar == SECOND_TAG ) {
+						return true; 
+					}
+					searchForEndTag = true;
+					return false;
+				}			
+				return false;
+			}
+			else if ( firstChar == BEGIN_TAG ) {
+				counter++; 
+				return false; 
+			}
+			else {
+				return false; 
+			}
+		}		
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML_generate_file.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML_generate_file.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML_generate_file.cpp	(revision 88)
@@ -7,4 +7,5 @@
 
 #include "Behavioural/include/XML.h"
+#include "Common/include/ErrorMorpheo.h"
 #include <fstream>
 
@@ -14,5 +15,5 @@
 #undef  FUNCTION
 #define FUNCTION "XML::generate_file"
-  void XML::generate_file (std::string encoding)
+  void XML::generate_file (std::string dirname, std::string encoding)
   {
     log_printf(FUNC,Behavioural,FUNCTION,"Begin");
@@ -20,10 +21,13 @@
     header (encoding);
 
-    std::string filename =  _name + "." + _filename_extension;
+    std::string filename = dirname + "/" + _name + _filename_extension;
 
-    std::cout << "Generate file \""<< filename << "\"" << std::endl;
+    msg_printf(INFORMATION,_("Generate file \"%s\"."),filename.c_str());
 
     std::ofstream file;
-    file.open(filename.c_str(),std::ios::out | std::ios::trunc);
+    file.open(filename.c_str() ,std::ios::out | std::ios::trunc);
+
+    if (!file)
+      throw ERRORMORPHEO(FUNCTION,toString(_("Error opening \"%s\" file.\n"),filename.c_str()));
 
     file << get_body();
@@ -34,8 +38,8 @@
   };
 
-  void XML::generate_file (void)
+  void XML::generate_file (std::string dirname)
   {
     log_printf(FUNC,Behavioural,FUNCTION,"Begin");
-    generate_file("UTF-8");
+    generate_file(dirname,"UTF-8");
     log_printf(FUNC,Behavioural,FUNCTION,"End");
   };
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML_get_body.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML_get_body.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML_get_body.cpp	(revision 88)
@@ -24,10 +24,10 @@
     log_printf(FUNC,Behavioural,FUNCTION,"Begin");
 
-    std::string body       = _body;
-    std::string tabulation = indent(depth);
+    std::string body = _body;
+    std::string tab  = indent(depth);
 
-//  body.insert(0,tabulation);
+    body.insert(0,tab);
     for (size_t pos=body.find('\n',0); (pos<body.length()-1); pos=body.find('\n',++pos))
-      body.insert(++pos,tabulation);
+      body.insert(++pos,tab);
 
     log_printf(FUNC,Behavioural,FUNCTION,"End");
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML_header.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML_header.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML_header.cpp	(revision 88)
@@ -26,7 +26,7 @@
     str += "\n";
     str += "<!--\n";
-    str += "\t"+toString(_("File : "))            + _name+"."+_filename_extension + "\n";
+    str += "\t"+toString(_("File : "))            + _name + _filename_extension + "\n";
     str += "\t"+toString(_("Date : "))            + ctime (&current_time );
-    str += "\t"+toString(_("Morpheo version : ")) + MORPHEO_VERSION +"\n";
+    str += "\t"+toString(_("Morpheo version : ")) + MORPHEO_HEADER +"\n";
     str += "\t"+toString(_("Comment : "))         + toString(_("it's a autogenerated file, don't modify")) +"\n";
     str += "-->\n";
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML_insert_XML.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML_insert_XML.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML_insert_XML.cpp	(revision 88)
@@ -13,9 +13,9 @@
 #undef  FUNCTION
 #define FUNCTION "XML::insert_XML"
-  bool XML::insert_XML (XML xml)
+  bool XML::insert_XML (XML xml, uint32_t offset_depth)
   {
     log_printf(FUNC,Behavioural,FUNCTION,"Begin");
     //return text (xml.get_body());
-    _body += xml.get_body(depth());
+    _body += xml.get_body(depth()+offset_depth);
     log_printf(FUNC,Behavioural,FUNCTION,"End");
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML_text.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML_text.cpp	(revision 85)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML_text.cpp	(revision 88)
@@ -16,5 +16,5 @@
   {
     log_printf(FUNC,Behavioural,FUNCTION,"Begin");
-    _body += indent()+text; // +"\n";
+    _body += text; // +"\n";
     log_printf(FUNC,Behavioural,FUNCTION,"End");
 
