2 // File: SALOME_ModuleCatalog_impl.cxx
3 // Created: Tue June 28 2001
4 // Author: Estelle Deville
6 // Copyright : CEA/DEN/DMSS/LGLS
9 #include "SALOME_ModuleCatalog_impl.hxx"
10 #include "SALOME_ModuleCatalog_Acomponent_impl.hxx"
13 #include <qstringlist.h>
14 #include <qfileinfo.h>
16 static const char* SEPARATOR = ":";
18 //----------------------------------------------------------------------
19 // Function : SALOME_ModuleCatalogImpl
20 // Purpose : Constructor
21 //----------------------------------------------------------------------
22 SALOME_ModuleCatalogImpl::SALOME_ModuleCatalogImpl(int argc, char** argv)
24 MESSAGE("Catalog creation");
26 // Empty used variables
27 _general_module_list.resize(0);
28 _general_path_list.resize(0);
30 _personal_module_list.resize(0);
31 _personal_path_list.resize(0);
33 // Parse the arguments given at server run
34 if (!_parseArguments(argc, argv,&_general_path,&_personal_path))
35 MESSAGE( "Error while argument parsing" )
37 // Test existency of files
38 if (_general_path == NULL)
39 MESSAGE( "Error the general catalog should be indicated" )
42 //MESSAGE("Parse general catalog");
43 // Affect the variables _general_module_list and _general_path_list
44 // with the common catalog
46 QStringList dirList = QStringList::split( SEPARATOR, _general_path, false ); // skip empty entries
47 for ( int i = 0; i < dirList.count(); i++ ) {
48 QFileInfo fileInfo( dirList[ i ] );
49 if ( fileInfo.isFile() && fileInfo.exists() ) {
50 _parse_xml_file(fileInfo.filePath(),_general_module_list, _general_path_list);
54 // Verification of _general_path_list content
55 if(!_verify_path_prefix(_general_path_list))
56 MESSAGE( "Error while parsing the general path list, differents pathes are associated to one computer, the first will be choosen" )
57 else MESSAGE("General path list OK");
59 if(_personal_path != NULL)
61 //MESSAGE("Parse personal catalog");
62 // Affect the variables _personal_module_list and _personal_path_list
63 // with the personal catalog
64 _parse_xml_file(_personal_path,_personal_module_list, _personal_path_list);
66 // Verification of _general_path_list content
67 if(!_verify_path_prefix(_personal_path_list))
68 MESSAGE("Error while parsing the personal path list, differents pathes are associated to one computer, the first will be choosen" )
69 else MESSAGE("Personal path list OK");
71 else MESSAGE("No personal catalog indicated or error while opening the personal catalog");
75 //----------------------------------------------------------------------
76 // Function : ~SALOME_ModuleCatalogImpl
77 // Purpose : Destructor
78 //----------------------------------------------------------------------
79 SALOME_ModuleCatalogImpl::~SALOME_ModuleCatalogImpl()
81 MESSAGE("Catalog Destruction");
85 //----------------------------------------------------------------------
86 // Function : GetComputerList
87 // Purpose : get a computer list
88 //----------------------------------------------------------------------
89 SALOME_ModuleCatalog::ListOfComputers*
90 SALOME_ModuleCatalogImpl::GetComputerList()
92 SALOME_ModuleCatalog::ListOfComputers_var _list_computers =
93 new SALOME_ModuleCatalog::ListOfComputers;
94 return _list_computers._retn();
97 //----------------------------------------------------------------------
98 // Function : GetPathPrefix
99 // Purpose : get the PathPrefix of a computer
100 //----------------------------------------------------------------------
102 SALOME_ModuleCatalogImpl::GetPathPrefix(const char* machinename) {
103 MESSAGE("Begin of GetPathPrefix")
104 // Variables initialisation
108 // Parse all the path prefixes
109 // looking for the wanted computer
110 for (unsigned int ind = 0 ; ind < _personal_path_list.size() ; ind++)
112 for (unsigned int ind1 = 0 ; ind1 < _personal_path_list[ind].ListOfComputer.size() ; ind1++)
114 if (strcmp(machinename, _personal_path_list[ind].ListOfComputer[ind1].c_str()) == 0)
118 // affect the path to be returned
119 const char* _temp = _personal_path_list[ind].path.c_str() ;
120 _path = new char[strlen(_temp)+1];
128 for (unsigned int ind = 0 ; ind < _general_path_list.size() ; ind++)
130 for (unsigned int ind1 = 0 ; ind1 < _general_path_list[ind].ListOfComputer.size() ; ind1++)
132 if (strcmp(machinename, _general_path_list[ind].ListOfComputer[ind1].c_str()) == 0)
136 // affect the path to be returned
137 const char* _temp = _general_path_list[ind].path.c_str() ;
138 _path = new char[strlen(_temp)+1];
148 //----------------------------------------------------------------------
149 // Function : GetComponentList
150 // Purpose : get a component list
151 // If a component is defined in the personal catalog and
152 // in the general catalog (same name), the component defined
153 // in the personal catalog is used
154 //----------------------------------------------------------------------
155 SALOME_ModuleCatalog::ListOfComponents*
156 SALOME_ModuleCatalogImpl::GetComponentList()
158 MESSAGE("Begin of GetComponentList");
159 SALOME_ModuleCatalog::ListOfComponents_var _list_components =
160 new SALOME_ModuleCatalog::ListOfComponents;
162 _list_components->length(_personal_module_list.size());
164 // All the components defined in the personal catalog are taken
165 for (unsigned int ind=0; ind < _personal_module_list.size();ind++)
167 _list_components[ind]=(_personal_module_list[ind].Parsercomponentname).c_str();
168 SCRUTE(_list_components[ind]) ;
171 int indice = _personal_module_list.size() ;
174 // The components in the general catalog are taken only if they're
175 // not defined in the personal catalog
176 for (unsigned int ind=0; ind < _general_module_list.size();ind++)
179 for (unsigned int ind1=0; ind1 < _personal_module_list.size();ind1++)
181 // searching if the component is already defined in
182 // the personal catalog
183 if ((_general_module_list[ind].Parsercomponentname.compare(_personal_module_list[ind1].Parsercomponentname)) == 0)
188 MESSAGE("A new component " << _general_module_list[ind].Parsercomponentname << " has to be to added in the list");
189 _list_components->length(indice+1);
190 // The component is not already defined => has to be taken
191 _list_components[indice]=(_general_module_list[ind].Parsercomponentname).c_str();
192 SCRUTE(_list_components[indice]) ;
197 MESSAGE("The component " <<_general_module_list[ind].Parsercomponentname << " was already defined in the personal catalog") ;
200 MESSAGE ( "End of GetComponentList" )
201 return _list_components._retn();
205 //----------------------------------------------------------------------
206 // Function : GetComponentIconeList
207 // Purpose : get a component list of component name and component icone
208 // If a component is defined in the personal catalog and
209 // in the general catalog (same name), the component defined
210 // in the personal catalog is used
211 //----------------------------------------------------------------------
212 SALOME_ModuleCatalog::ListOfIAPP_Affich*
213 SALOME_ModuleCatalogImpl::GetComponentIconeList()
215 MESSAGE("Begin of GetComponentIconeList");
217 SALOME_ModuleCatalog::ListOfIAPP_Affich_var _list_components_icone =
218 new SALOME_ModuleCatalog::ListOfIAPP_Affich;
220 _list_components_icone->length(_personal_module_list.size());
222 // All the components defined in the personal catalog are taken
223 for (unsigned int ind=0; ind < _personal_module_list.size();ind++)
225 _list_components_icone[ind].modulename=(_personal_module_list[ind].Parsercomponentname).c_str();
226 _list_components_icone[ind].moduleusername=(_personal_module_list[ind].Parsercomponentusername).c_str();
227 _list_components_icone[ind].moduleicone=(_personal_module_list[ind].Parsercomponenticone).c_str();
228 //SCRUTE(_list_components_icone[ind].modulename);
229 //SCRUTE(_list_components_icone[ind].moduleicone);
232 int indice = _personal_module_list.size() ;
235 // The components in the general catalog are taken only if they're
236 // not defined in the personal catalog
237 for (unsigned int ind=0; ind < _general_module_list.size();ind++)
240 for (unsigned int ind1=0; ind1 < _personal_module_list.size();ind1++)
242 // searching if the component is aleready defined in
243 // the personal catalog
244 if ((_general_module_list[ind].Parsercomponentname.compare(_personal_module_list[ind1].Parsercomponentname)) == 0)
249 // MESSAGE("A new component " << _general_module_list[ind].Parsercomponentname << " has to be to added in the list");
250 _list_components_icone->length(indice+1);
251 // The component is not already defined => has to be taken
252 _list_components_icone[indice].modulename=(_general_module_list[ind].Parsercomponentname).c_str();
253 _list_components_icone[indice].moduleusername=(_general_module_list[ind].Parsercomponentusername).c_str();
254 _list_components_icone[indice].moduleicone=(_general_module_list[ind].Parsercomponenticone).c_str();
255 //SCRUTE(_list_components_icone[indice].modulename) ;
256 //SCRUTE(_list_components_icone[indice].moduleicone);
261 //MESSAGE("The component " <<_general_module_list[ind].Parsercomponentname << " was already defined in the personal catalog");
264 return _list_components_icone._retn() ;
267 //----------------------------------------------------------------------
268 // Function : GetTypedComponentList
269 // Purpose : get a component list of a wanted type
270 // If a component is defined in the personal catalog and
271 // in the general catalog (same name), the component defined
272 // in the personal catalog is used
273 //----------------------------------------------------------------------
274 SALOME_ModuleCatalog::ListOfComponents*
275 SALOME_ModuleCatalogImpl::GetTypedComponentList(SALOME_ModuleCatalog::ComponentType component_type)
277 MESSAGE("Begin of GetTypedComponentList");
278 SALOME_ModuleCatalog::ListOfComponents_var _list_typed_component =
279 new SALOME_ModuleCatalog::ListOfComponents;
282 _list_typed_component->length(0);
283 // Transform SALOME_ModuleCatalog::ComponentType in ParserComponentType
284 ParserComponentType _temp_component_type;
285 switch(component_type){
286 case SALOME_ModuleCatalog::GEOM:
287 _temp_component_type = GEOM ;
289 case SALOME_ModuleCatalog::MESH:
290 _temp_component_type = MESH;
292 case SALOME_ModuleCatalog::Med:
293 _temp_component_type = Med;
295 case SALOME_ModuleCatalog::SOLVER:
296 _temp_component_type = SOLVER;
298 case SALOME_ModuleCatalog::DATA:
299 _temp_component_type = DATA;
301 case SALOME_ModuleCatalog::VISU:
302 _temp_component_type = VISU;
304 case SALOME_ModuleCatalog::SUPERV:
305 _temp_component_type = SUPERV;
307 case SALOME_ModuleCatalog::OTHER:
308 _temp_component_type = OTHER;
312 // All the components in the personal catalog are taken
313 for (unsigned int ind=0; ind < _personal_module_list.size();ind++)
315 if (_personal_module_list[ind].Parsercomponenttype == _temp_component_type)
317 _list_typed_component->length(_j + 1);
318 _list_typed_component[_j] = (_modulelist[ind].Parsercomponentname).c_str();
319 //SCRUTE(_list_typed_component[_j])
324 int indice = _list_typed_component->length() ;
327 // The components in the general catalog are taken only if they're
328 // not defined in the personal catalog
329 for (unsigned int ind=0; ind < _general_module_list.size();ind++)
333 if(_general_module_list[ind].Parsercomponenttype == _temp_component_type)
335 for (unsigned int ind1=0; ind1 < _personal_module_list.size();ind1++)
337 // searching if the component is aleready defined in
338 // the personal catalog
339 if ((_general_module_list[ind].Parsercomponentname.compare(_personal_module_list[ind1].Parsercomponentname)) == 0)
344 //MESSAGE("A new component " << _general_module_list[ind].Parsercomponentname << " has to be to added in the list");
345 _list_typed_component->length(indice+1);
346 // The component is not already defined => has to be taken
347 _list_typed_component[indice]=(_general_module_list[ind].Parsercomponentname).c_str();
348 //SCRUTE(_list_typed_component[indice]) ;
353 //MESSAGE("The component " <<_general_module_list[ind].Parsercomponentname << " was already defined in the personal catalog") ;
358 return _list_typed_component._retn();
361 //----------------------------------------------------------------------
362 // Function : GetComponent
363 // Purpose : get a component
364 // If a component is defined in the personal catalog and
365 // in the general catalog (same name), the component defined
366 // in the personal catalog is used
367 //----------------------------------------------------------------------
368 SALOME_ModuleCatalog::Acomponent_ptr
369 SALOME_ModuleCatalogImpl::GetComponent(const char* componentname)
371 SALOME_ModuleCatalog::Acomponent_ptr compo;
372 SALOME_ModuleCatalog::ListOfDefInterface _list_interfaces;
373 _list_interfaces.length(0);
374 char* _constraint = NULL;
376 char* _componentusername = NULL;
377 SALOME_ModuleCatalog::ComponentType _componenttype = SALOME_ModuleCatalog::OTHER; // default initialisation
378 CORBA::Boolean _componentmultistudy = false ; // default initialisation
379 ListOfPathPrefix _pathes ;
385 // Looking for component named "componentname" in the personal catalog
386 // If found, get name, interfaces and constraint
387 // If not found, looking for component named "componentname" in
388 // the general catalog
389 // If found, get name, interfaces and constraint
390 // If not found, NULL pointer is returned
392 for (unsigned int ind=0; ind < _personal_module_list.size();ind++)
394 if (strcmp((_personal_module_list[ind].Parsercomponentname).c_str(),componentname) == 0)
396 //MESSAGE("Component named " << componentname << " found in the personal catalog");
400 _constraint = new char[strlen(_personal_module_list[ind].Parserconstraint.c_str()) + 1];
401 _constraint = CORBA::string_dup(_personal_module_list[ind].Parserconstraint.c_str());
403 // get component type
404 switch(_personal_module_list[ind].Parsercomponenttype){
406 _componenttype = SALOME_ModuleCatalog::GEOM;
409 _componenttype = SALOME_ModuleCatalog::MESH;
412 _componenttype = SALOME_ModuleCatalog::Med;
415 _componenttype = SALOME_ModuleCatalog::SOLVER;
418 _componenttype = SALOME_ModuleCatalog::DATA;
421 _componenttype = SALOME_ModuleCatalog::VISU;
424 _componenttype = SALOME_ModuleCatalog::SUPERV;
427 _componenttype = SALOME_ModuleCatalog::OTHER;
431 // get component multistudy
432 _componentmultistudy = _personal_module_list[ind].Parsercomponentmultistudy ;
434 // get component icone
435 _icone = CORBA::string_dup(_personal_module_list[ind].Parsercomponenticone.c_str());
437 // get component user name
438 _componentusername = CORBA::string_dup(_personal_module_list[ind].Parsercomponentusername.c_str());
440 // get component interfaces
441 _list_interfaces = duplicate_interfaces(_personal_module_list[ind].ParserListInterface);
444 _pathes = duplicate_pathes(_personal_path_list);
451 SALOME_ModuleCatalog_AcomponentImpl* aComponentImpl =
452 new SALOME_ModuleCatalog_AcomponentImpl(componentname,
456 _componentmultistudy,
461 compo = aComponentImpl->_this();
464 // Not found in the personal catalog => searching in the general catalog
466 for (unsigned int ind=0; ind < _general_module_list.size();ind++)
468 if (strcmp((_general_module_list[ind].Parsercomponentname).c_str(),componentname) == 0)
470 //MESSAGE("Component named " << componentname << " found in the general catalog");
474 _constraint = new char[strlen(_general_module_list[ind].Parserconstraint.c_str()) + 1];
475 _constraint = CORBA::string_dup(_general_module_list[ind].Parserconstraint.c_str());
478 // get component type
479 switch(_general_module_list[ind].Parsercomponenttype){
481 _componenttype = SALOME_ModuleCatalog::GEOM;
484 _componenttype = SALOME_ModuleCatalog::MESH;
487 _componenttype = SALOME_ModuleCatalog::Med;
490 _componenttype = SALOME_ModuleCatalog::SOLVER;
493 _componenttype = SALOME_ModuleCatalog::DATA;
496 _componenttype = SALOME_ModuleCatalog::VISU;
499 _componenttype = SALOME_ModuleCatalog::SUPERV;
502 _componenttype = SALOME_ModuleCatalog::OTHER;
507 // get component multistudy
508 _componentmultistudy = _general_module_list[ind].Parsercomponentmultistudy ;
510 // get component icone
511 _icone = CORBA::string_dup(_general_module_list[ind].Parsercomponenticone.c_str());
513 // get component user name
514 _componentusername = CORBA::string_dup(_general_module_list[ind].Parsercomponentusername.c_str());
516 // get component interfaces
517 _list_interfaces = duplicate_interfaces(_general_module_list[ind].ParserListInterface);
520 _pathes = duplicate_pathes(_general_path_list);
526 SALOME_ModuleCatalog_AcomponentImpl* aComponentImpl =
527 new SALOME_ModuleCatalog_AcomponentImpl(componentname,
531 _componentmultistudy,
536 compo = aComponentImpl->_this();
539 // Not found in the personal catalog and in the general catalog
540 // return NULL object
542 MESSAGE("Component with name " << componentname << " not found in catalog");
549 //----------------------------------------------------------------------
550 // Function : _parse_xml_file
551 // Purpose : parse one module catalog
552 //----------------------------------------------------------------------
554 SALOME_ModuleCatalogImpl::_parse_xml_file(const char* file,
555 ListOfParserComponent& modulelist,
556 ListOfParserPathPrefix& pathlist)
558 SALOME_ModuleCatalog_Handler* handler = new SALOME_ModuleCatalog_Handler();
561 QXmlInputSource source(xmlFile);
563 QXmlSimpleReader reader;
564 reader.setContentHandler( handler );
565 reader.setErrorHandler( handler );
566 reader.parse( source );
569 for ( ind = 0; ind < _modulelist.size(); ind++)
570 modulelist.push_back(_modulelist[ind]) ;
571 for ( ind = 0; ind < _pathlist.size(); ind++)
572 pathlist.push_back(_pathlist[ind]) ;
575 //----------------------------------------------------------------------
576 // Function : duplicate_interfaces
577 // Purpose : create a list of interfaces from the parsing of the catalog
578 //----------------------------------------------------------------------
579 SALOME_ModuleCatalog::ListOfDefInterface
580 SALOME_ModuleCatalogImpl::duplicate_interfaces(ListOfDefinitionInterface list_interface)
582 SALOME_ModuleCatalog::ListOfDefInterface _list_interfaces;
583 unsigned int _length_interfaces = list_interface.size();
584 _list_interfaces.length(_length_interfaces);
586 for (unsigned int ind = 0; ind < _length_interfaces; ind++)
588 //duplicate interface name
589 _list_interfaces[ind].interfacename = CORBA::string_dup(list_interface[ind].Parserinterfacename.c_str());
591 // duplicate service list
592 unsigned int _length_services = list_interface[ind].Parserinterfaceservicelist.size();
593 _list_interfaces[ind].interfaceservicelist.length(_length_services);
595 for (unsigned int ind1 = 0; ind1 < _length_services ; ind1 ++)
597 // duplicate service name
598 _list_interfaces[ind].interfaceservicelist[ind1].ServiceName =
599 CORBA::string_dup(list_interface[ind].Parserinterfaceservicelist[ind1].ParserServiceName.c_str());
601 // duplicate service by default
602 _list_interfaces[ind].interfaceservicelist[ind1].Servicebydefault =
603 list_interface[ind].Parserinterfaceservicelist[ind1].ParserServicebydefault;
605 // duplicate in Parameters
606 unsigned int _length_in_param = list_interface[ind].Parserinterfaceservicelist[ind1].ParserServiceinParameter.size();
607 _list_interfaces[ind].interfaceservicelist[ind1].ServiceinParameter.length(_length_in_param);
608 for (unsigned int ind2 = 0; ind2 < _length_in_param ; ind2 ++)
610 // duplicate parameter type
611 _list_interfaces[ind].interfaceservicelist[ind1].ServiceinParameter[ind2].Parametertype = CORBA::string_dup(list_interface[ind].Parserinterfaceservicelist[ind1].ParserServiceinParameter[ind2].ParserParamtype.c_str());
613 // duplicate parameter name
614 _list_interfaces[ind].interfaceservicelist[ind1].ServiceinParameter[ind2].Parametername = CORBA::string_dup(list_interface[ind].Parserinterfaceservicelist[ind1].ParserServiceinParameter[ind2].ParserParamname.c_str());
617 // duplicate out Parameters
618 unsigned int _length_out_param = list_interface[ind].Parserinterfaceservicelist[ind1].ParserServiceoutParameter.size();
619 _list_interfaces[ind].interfaceservicelist[ind1].ServiceoutParameter.length(_length_out_param);
620 for (unsigned int ind2 = 0; ind2 < _length_out_param ; ind2 ++)
622 // duplicate parameter type
623 _list_interfaces[ind].interfaceservicelist[ind1].ServiceoutParameter[ind2].Parametertype = CORBA::string_dup(list_interface[ind].Parserinterfaceservicelist[ind1].ParserServiceoutParameter[ind2].ParserParamtype.c_str());
625 // duplicate parameter name
626 _list_interfaces[ind].interfaceservicelist[ind1].ServiceoutParameter[ind2].Parametername = CORBA::string_dup(list_interface[ind].Parserinterfaceservicelist[ind1].ParserServiceoutParameter[ind2].ParserParamname.c_str());
631 return _list_interfaces;
635 //----------------------------------------------------------------------
636 // Function : duplicate_pathes
637 // Purpose : create the path prefix structures from the catalog parsing
638 //----------------------------------------------------------------------
640 SALOME_ModuleCatalogImpl::duplicate_pathes(ListOfParserPathPrefix pathes)
642 ListOfPathPrefix _pathes ;
644 unsigned int _length = pathes.size() ;
645 _pathes.resize(_length);
646 unsigned int _length_comput = 0;
648 for (unsigned int ind = 0; ind < _length ; ind++)
651 _pathes[ind].path = CORBA::string_dup(pathes[ind].path.c_str()) ;
652 //MESSAGE("Prefix : " << _pathes[ind].path);
654 _length_comput = pathes[ind].ListOfComputer.size() ;
655 _pathes[ind].ListOfComputer.resize(_length_comput);
656 for (unsigned int ind1 = 0; ind1 <_length_comput ; ind1++)
658 // duplicate computer name
659 _pathes[ind].ListOfComputer[ind1] = CORBA::string_dup(pathes[ind].ListOfComputer[ind1].c_str());
660 //MESSAGE("Computer associated to the prefix : " <<_pathes[ind].ListOfComputer[ind1]);
667 //----------------------------------------------------------------------
668 // Function : _verify_path_prefix
669 // Purpose : verify the path prefix structures from the catalog parsing
670 // Verify that there only one path prefix associated to a
671 // particular computer
672 //----------------------------------------------------------------------
674 SALOME_ModuleCatalogImpl::_verify_path_prefix(ListOfParserPathPrefix pathlist)
676 bool _return_value = true;
677 vector<string> _machine_list;
678 _machine_list.resize(0);
680 // Fill a list of all computers indicated in the path list
681 for (unsigned int ind = 0; ind < pathlist.size(); ind++)
683 for (unsigned int ind1 = 0 ; ind1 < pathlist[ind].ListOfComputer.size(); ind1++)
685 _machine_list.push_back(pathlist[ind].ListOfComputer[ind1]);
689 // Parse if a computer name is twice in the list of computers
690 for (unsigned int ind = 0; ind < _machine_list.size(); ind++)
692 for (unsigned int ind1 = ind+1 ; ind1 < _machine_list.size(); ind1++)
694 if(_machine_list[ind].compare(_machine_list[ind1]) == 0)
696 MESSAGE( "The computer " << _machine_list[ind] << " is indicated more than once in the path list")
697 _return_value = false;
701 return _return_value;
705 //----------------------------------------------------------------------
706 // Function : _parseArguments
707 // Purpose : parse arguments to get general and personal catalog files
708 //----------------------------------------------------------------------
710 SALOME_ModuleCatalogImpl::_parseArguments(int argc, char **argv,
714 bool _return_value = true;
717 for (int ind = 0; ind < argc ; ind++)
720 if (strcmp(argv[ind],"-help") == 0)
722 INFOS( "Usage: " << argv[0] << " -common 'path to general catalog' -personal 'path to personal catalog' -ORBInitRef NameService=corbaname::localhost");
723 _return_value = false ;
725 if (strcmp(argv[ind],"-common") == 0)
729 // General catalog file
730 *_general = argv[ind + 1] ;
731 /* ifstream _general_file(*_general);
734 MESSAGE( "Sorry the file " << *_general << " can't be open" )
736 _return_value = false;
741 else if (strcmp(argv[ind],"-personal") == 0)
745 // Personal catalog file
746 *_personal = argv[ind + 1] ;
747 /* ifstream _personal_file(*_personal);
750 MESSAGE("Sorry the file " << *_personal << " can't be open" )
752 _return_value = false;
758 return _return_value;