924 lines
42 KiB
C++
Executable file
924 lines
42 KiB
C++
Executable file
|
|
// This file is part of the Herezh++ application.
|
|
//
|
|
// The finite element software Herezh++ is dedicated to the field
|
|
// of mechanics for large transformations of solid structures.
|
|
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
|
|
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
|
|
//
|
|
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
|
//
|
|
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
|
// AUTHOR : Gérard Rio
|
|
// E-MAIL : gerardrio56@free.fr
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License,
|
|
// or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
|
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
// See the GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
//
|
|
// For more information, please consult: <https://herezh.irdl.fr/>.
|
|
|
|
|
|
# include <iostream>
|
|
using namespace std; //introduces namespace std
|
|
#include <stdlib.h>
|
|
#include "Sortie.h"
|
|
#include "UtilLecture.h"
|
|
#include "Sortie.h"
|
|
|
|
#include <fstream>
|
|
#include <cstdlib>
|
|
#include <iomanip>
|
|
#include <algorithm>
|
|
#include "ParaGlob.h"
|
|
#include "CharUtil.h"
|
|
#include "TypeQuelconque.h"
|
|
#include <limits>
|
|
|
|
|
|
// méthodes de classe internes
|
|
// surcharge de l'operateur d'ecriture
|
|
ostream & operator << (ostream & sort,const UtilLecture::Position_BI & a)
|
|
{ // écriture du type
|
|
sort << "incre_posi_(nb_et_posi): ";
|
|
// les données
|
|
sort << a.num_incr << " " ;
|
|
// pour la position c'est plus délicat et peut-être pas portable ??
|
|
// normalement on a la position et un paramètre state ?
|
|
// que l'on sauvegarde manuellement because pas de surcharge actuellement
|
|
// () donne normalement l'ofset, et la fonction state() donne le state (?)
|
|
streamoff errt = (streamoff) a.position; // utilisation de la conversion de type forcée
|
|
#ifndef ENLINUX_STREAM
|
|
sort << errt << " " << a.position.state() << " ";
|
|
#else
|
|
sort << errt;
|
|
#endif
|
|
return sort;
|
|
};
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & entree, UtilLecture::Position_BI& a)
|
|
{ // vérification du type
|
|
string type;
|
|
entree >> type;
|
|
if (type != "incre_posi_(nb_et_posi):")
|
|
{Sortie (1);
|
|
return entree;
|
|
};
|
|
// entrée des données
|
|
entree >> a.num_incr;
|
|
// en fait pour la position du stream il y a deux grandeurs (sur mac)
|
|
// et on est obligé d'utiliser la surcharge standard de copie (?)
|
|
// pour remplir a !! car
|
|
// streampos contiend deux éléments sur mac !! qui sont en private !!
|
|
// sur unix !!!!! a priori un seul élément
|
|
|
|
#ifndef ENLINUX_STREAM
|
|
{long long titi1;
|
|
long long int titi2;
|
|
entree >> titi1 >> titi2;
|
|
streampos ee(titi1); ee.state(titi2);
|
|
a.position = ee;
|
|
}
|
|
#else
|
|
{long long titi1;
|
|
entree >> titi1 ;
|
|
streampos ee(titi1);
|
|
a.position = ee;
|
|
};
|
|
#endif
|
|
|
|
return entree;
|
|
};
|
|
|
|
// CONSTRUCTEURS :
|
|
// il y a passage éventuelle d'argument : argc=le nombre d'argument
|
|
// argv : donne un tableau correspondant de mots clés
|
|
// ---> lecture de la racine du nom du fichier princial
|
|
UtilLecture::UtilLecture (int argc, const char * argv[]) :
|
|
longueur(1500) // longueur maxi du tableau de travail
|
|
,nomCourant(),nomRacine(),ptrfich(NULL),tablcar(NULL),tableau(NULL),lec_ent_info(-10)
|
|
,ent_BI(NULL),sort_BI(NULL),ent_PI(NULL),sort_PI(NULL),liste_posi_BI()
|
|
,dernier_increment_lu(0),ptrcommandefich(NULL),ptrschemaXMLfich(NULL)
|
|
,sort_princ_vrml(NULL),sort_legende_vrml(NULL),sort_princ_maple(NULL)
|
|
,sort__temps_cpu(NULL)
|
|
,sort_princ_geomview(NULL),sort_legende_geomview(NULL)
|
|
,sort_initial_Gid(NULL), sort_resultat_Gid(NULL)
|
|
,ent_CommandeVisu(NULL),sort_CommandeVisu(NULL)
|
|
,tablcarCVisu(NULL),tableauCVisu(NULL),maille1(NULL)
|
|
,ptnomCVisu(NULL),pteurnom(NULL),nomRacineCVisu()
|
|
,sort_initial_Gmsh(NULL),sort_resultat_Gmsh(),noms_base_fichiers_gmsh()
|
|
,tabMultiLignes(NULL)
|
|
|
|
{ bool fr = ParaGlob::Francais(); // pour simplifier
|
|
// information concernant l'entrée des données
|
|
if (fr){cout << "\n -- initialisation de l'entree des donnees ";}
|
|
else {cout << "\n -- initialisation of the data input ";};
|
|
// tout d'abord on regarde qu'elle etait le nom utilise lors de la derniere
|
|
// execution du programme
|
|
ifstream auxi("ancienNom");
|
|
string ancien; bool ouverture_ancien=false;
|
|
// on regarde l'utilisation de la sauvegarde de l'ancienne racine
|
|
if (!auxi)
|
|
//cas d'une erreur a l'ouverture parce que pas de fichier
|
|
// lecture de la racine du nom du fichier princial
|
|
{ ouverture_ancien=false;}
|
|
else
|
|
{ auxi >> ancien; // lecture de l'ancien nom
|
|
// lecture de la racine du nom du fichier princial
|
|
if (ancien.length() == 0)
|
|
{ouverture_ancien=false;}
|
|
else
|
|
{ouverture_ancien=true;};
|
|
};
|
|
// on regarde maintenant s'il y a passage du nom dans les arguments
|
|
lec_ent_info=-10; // init
|
|
bool entree_par_argument= EntreeParArgument(argc,argv);
|
|
// on regarde s'il y a eu pb et que rien n'est initialisé, il faut arrêter
|
|
if (entree_par_argument)
|
|
if (lec_ent_info==-100) return;
|
|
|
|
// s'il n'y a pas eu d'entrée par argument on effectue une entrée interactive
|
|
if (!entree_par_argument)
|
|
EntreeInteractive(ancien,ouverture_ancien);
|
|
// on regarde s'il y a eu pb et que rien n'est initialisé, il faut arrêter
|
|
if (lec_ent_info==-100) return;
|
|
|
|
|
|
// traitement en fonction de lec_ent_info
|
|
switch (lec_ent_info)
|
|
{ case -12 : // --------- cas de la construction shema XML d'entrée de données .info ----
|
|
{ if (fr) {cout << " racine du nom de fichier principal = " << nomRacine << endl;}
|
|
else {cout << " first part of the name for the principal file = " << nomRacine << endl;};
|
|
// stockage du nom de fichier courant ouvert
|
|
nomCourant = nomRacine;
|
|
break;
|
|
}
|
|
case -11 : // --------- cas de la construction d'un fichier de commande .info ----
|
|
{ if (fr) {cout << " racine du nom de fichier principal = " << nomRacine << endl;}
|
|
else {cout << " first part of the name for the principal file = " << nomRacine << endl;};
|
|
// stockage du nom de fichier courant ouvert
|
|
nomCourant = nomRacine;
|
|
break;
|
|
}
|
|
case 0 : case 3: // ------------ cas d'une entrée via un fichier .info ----------
|
|
{ if (fr) {cout << " racine du nom de fichier principal = " << nomRacine << endl;}
|
|
else {cout << " first part of the name for the principal file = " << nomRacine << endl;};
|
|
// stockage du nom de fichier courant ouvert
|
|
nomCourant = nomRacine;
|
|
break;
|
|
}
|
|
case 1 : // --------------cas d'une entrée via un fichier .base-info------------
|
|
{ if (fr) {cout << "\n entrer le nom du fichier .base-info : (" << ancien <<").base-info \n"
|
|
<< " ou repondre o ou 0 si l'on veut l'ancien nom (le dernier utilise)\n";}
|
|
else {cout << "\n enter the name of the file .base-info : (" << ancien <<").base-info \n"
|
|
<< " or answer y or Y if you want the old name (last used) \n";};
|
|
nomRacine= lect_chaine();
|
|
if ((nomRacine == "0")||(nomRacine == "o")||(nomRacine == "y")||(nomRacine == "Y"))
|
|
{ nomRacine = ancien;
|
|
// stockage du nom de fichier courant ouvert
|
|
nomCourant = nomRacine;
|
|
};
|
|
break;
|
|
}
|
|
case 2 : // --------------cas d'une entrée via un serveur .base-info------------
|
|
{ if (fr) {cout << " cas actuellement non traite = entree de donnees via un serveur base-info \n";}
|
|
else {cout << " at this time, not possible = input data with a server for <base-info> file\n";};
|
|
cout << " UtilLecture::UtilLecture () " << endl;
|
|
Sortie(1);
|
|
break;
|
|
}
|
|
default :
|
|
if (fr) {cout << "\nErreur : valeur incorrecte de lec_ent_info =" << lec_ent_info << " !\n";}
|
|
else {cout << "\nError : incorrect value for lec_ent_info =" << lec_ent_info << " !\n";};
|
|
cout << "UtilLecture::UtilLecture () " << endl;
|
|
Sortie(1);
|
|
};
|
|
|
|
// sauvegarde de la racine dans le cas où on ne veut pas un schéma
|
|
auxi.close();
|
|
if (lec_ent_info != -12)
|
|
{ofstream auxo("ancienNom");
|
|
if (auxo)
|
|
{auxo << nomRacine;} // sauvegarde de la racine
|
|
else
|
|
{if (fr) {cout << "pb en ouverture en ecriture du fichier <ancienNom> , on continu quand meme ";}
|
|
else {cout << "problem in the opening of the file <ancienNom> but we continue as we can !! ";};
|
|
};
|
|
};
|
|
|
|
tablcar = new char [longueur] ; // def du tableau de travail
|
|
tableau = new char [longueur] ; // def du tableau intermediaire
|
|
tabMultiLignes = new char [longueur]; // def du tableau pour le stockage de plusieurs lignes
|
|
// def du flot d'entree filtree en memoire
|
|
// utilise pour les conversions de type en lecture
|
|
#ifndef ENLINUX_STREAM
|
|
entree = new istringstream(tablcar,longueur) ;
|
|
#else
|
|
entree = new istrstream(tablcar,longueur) ;
|
|
#endif
|
|
// adressage du pointeur de nomRacine
|
|
pteurnom = (char*)nomRacine.c_str();
|
|
nomRacineCVisu = nomRacine; // par défaut le nom de la racine de .CVisu est identique
|
|
ptnomCVisu = (char*)nomRacineCVisu.c_str();
|
|
|
|
// lecture des commandes de visualisation (même technique en simplifié que pour .info)
|
|
tablcarCVisu = new char [longueur] ; // def du tableau de travail
|
|
tableauCVisu = new char [longueur] ; // def du tableau intermediaire
|
|
// def du flot d'entree filtree en memoire
|
|
// utilise pour les conversions de type en lecture
|
|
#ifndef ENLINUX_STREAM
|
|
entCVisu = new istringstream(tablcarCVisu,longueur) ;
|
|
#else
|
|
entCVisu = new istrstream(tablcarCVisu,longueur) ;
|
|
#endif
|
|
|
|
};
|
|
|
|
// DESTRUCTEUR :
|
|
UtilLecture::~UtilLecture ()
|
|
{ if (ptrfich!= NULL) {delete ptrfich;ptrfich=NULL;}
|
|
if (ptrcommandefich!= NULL) {delete ptrcommandefich;ptrcommandefich=NULL;}
|
|
if (ptrschemaXMLfich!= NULL) {delete ptrschemaXMLfich;ptrschemaXMLfich=NULL;}
|
|
// ****** pour l'instant la suite ne marche pas ?? mais ce n'est pas normal
|
|
// ****** erreur bizarre
|
|
// c'est sans doute qu'il y a une confusion entre des vrais tableaux c de charactères = chaine de caractère
|
|
// et le tableau du type caractère et je me demande s'il faut des destructeurs pour ce type de tableau
|
|
//// = modif nov 2009 avec le passage sur linux .... il faudra regarder cela du plus près ***************
|
|
|
|
|
|
|
|
// if (tablcar != NULL) {delete [] tablcar;tablcar=NULL;}
|
|
//// if (tableau != NULL) {delete [] tableau;tableau=NULL;};
|
|
// if (tablcarCVisu != NULL) {delete [] tablcarCVisu;tablcarCVisu=NULL;}
|
|
//// if (tableauCVisu != NULL) {delete [] tableauCVisu;tableauCVisu=NULL;};
|
|
//// if (tabMultiLignes != NULL) {delete [] tabMultiLignes; tabMultiLignes=NULL;};
|
|
Fermeture_base_info();
|
|
Fermeture_fichier_principal_vrml();
|
|
Fermeture_fichier_principal_vrml();
|
|
Fermeture_fichier_principal_maple();
|
|
Fermeture_fichier_principal_geomview();
|
|
Fermeture_fichier_principal_geomview();
|
|
Fermeture_fichier_initial_Gid();
|
|
Fermeture_fichier_resultat_Gid();
|
|
Fermeture_fichier_initial_Gmsh();
|
|
Fermeture_TousLesFichiersResultats_Gmsh();
|
|
Fermeture_fichier_temps_cpu();
|
|
} ;
|
|
|
|
// ouverture du fichier principal principal de lecture
|
|
int UtilLecture::OuvrirFichier ()
|
|
{ char nomm[132];
|
|
char*fileName = nomm;
|
|
bool fr = ParaGlob::Francais(); // pour simplifier
|
|
strcpy(fileName, pteurnom);
|
|
// traitement en fonction de lec_ent_info
|
|
switch (lec_ent_info)
|
|
{ case -12 : // --------- cas de la construction shema XML d'entrée de données .info ----
|
|
{ ptrschemaXMLfich = new ofstream(strcat(fileName,".xsd"));
|
|
if(!(ptrschemaXMLfich->is_open()))
|
|
{ if (fr){cout << "\n erreur en ouverture du fichier " << fileName << endl;}
|
|
else {cout << "\n error in opening of the file " << fileName << endl;};
|
|
Sortie(1);
|
|
};
|
|
break;
|
|
}
|
|
case -11 : // ------------ cas d'une sortie via un fichier .info ----------
|
|
{// on va essayer d'éviter d'écraser un fichier déjà existant.
|
|
// a) on essaie d'ouvrir le fichier en lecture
|
|
ifstream * essai = new ifstream(strcat(fileName,".info"));
|
|
string rep(" ");
|
|
if (essai->is_open())
|
|
{// l'ouverture est ok ==> il existe déjà
|
|
cout << "\n ****** attention, le fichier "<<fileName
|
|
<< " existe deja !!\n voulez-vous vraiment l'ecraser ? (o / n) "<<flush;
|
|
rep = lect_o_n(false);
|
|
Minuscules(rep);
|
|
if (rep != "o")
|
|
{ cout << "\n pas d'ecrasement ==> donc on termine l'execution ";
|
|
Sortie(1);
|
|
}
|
|
else // sinon on veut vraiment l'écraser
|
|
{essai->close();
|
|
}; // on ferme le fichier en lecture et on continue
|
|
};
|
|
// cas où le fichier n'existe pas ou qu'on veut écraser un fichier existant
|
|
// ptrcommandefich = new ofstream(strcat(fileName,".info"));
|
|
ptrcommandefich = new ofstream(fileName); // fileName contient déjà le suffixe .info
|
|
if(!(ptrcommandefich->is_open()))
|
|
{ if (fr){cout << "\n erreur en ouverture du fichier " << fileName << endl;}
|
|
else {cout << "\n error in opening of the file " << fileName << endl;};
|
|
Sortie(1);
|
|
};
|
|
break;
|
|
}
|
|
case 0 : // ------------ cas d'une entrée via un fichier .info ----------
|
|
{ ptrfich = new ifstream(strcat(fileName,".info"));
|
|
if(!(ptrfich->is_open()))
|
|
{ if (fr){cout << "\n erreur en ouverture du fichier " << fileName << endl;}
|
|
else {cout << "\n error in opening of the file " << fileName << endl;};
|
|
Sortie(1);
|
|
};
|
|
// initialisation de la liste chainee d'ouverture de fichier
|
|
string no(fileName);
|
|
maille1 = new PointFich (NULL,ptrfich,no);
|
|
break;
|
|
}
|
|
case 1 : // --------------cas d'une entrée via un fichier .base-info------------
|
|
{ Ouverture_base_info("lecture");
|
|
break;
|
|
}
|
|
case 2 : // --------------cas d'une entrée via un serveur .base-info------------
|
|
{ if (fr){cout << " cas actuellement non traite = entree de données via un serveur base-info \n";}
|
|
else {cout << " case not possible for the moment = input data with a server for <base-info> file \n";};
|
|
cout << " UtilLecture::OuvrirFichier () " << endl;
|
|
Sortie(1);
|
|
break;
|
|
}
|
|
default :
|
|
if (fr){cout << "\nErreur : valeur incorrecte de lec_ent_info =" << lec_ent_info << " !\n";}
|
|
else {cout << "\nerror : incorrect value of lec_ent_info =" << lec_ent_info << " !\n";};
|
|
cout << "UtilLecture::OuvrirFichier () " << endl;
|
|
Sortie(1);
|
|
};
|
|
return lec_ent_info;
|
|
};
|
|
|
|
// raffraichir le dernier fichier de lecture .info en cours
|
|
// il y a fermeture puis ouverture au même endroit du fichier .info
|
|
void UtilLecture::Raffraichir_pointInfo()
|
|
{ // on commence par récupérer l'adresse actuelle dans le fichier
|
|
streampos position = maille1->sauvePtr->tellg();
|
|
// puis le nom
|
|
string nom_du_pointInfo = maille1->nom;
|
|
// on ferme le fichier
|
|
delete maille1->sauvePtr;
|
|
// on le reouvre
|
|
maille1->sauvePtr = new ifstream(nom_du_pointInfo.c_str());
|
|
bool fr = ParaGlob::Francais(); // pour simplifier
|
|
if(!(maille1->sauvePtr->is_open()))
|
|
{ if (fr){cout << "\n erreur en re-ouverture du fichier " << nom_du_pointInfo << endl;}
|
|
else {cout << "\n error in re-opening of the file " << nom_du_pointInfo << endl;};
|
|
Sortie(1);
|
|
};
|
|
// on se repositionne dans le fichier
|
|
maille1->sauvePtr->clear(); // on remet à 0 les bits de contrôle au cas où
|
|
maille1->sauvePtr->seekg(position, ios::beg);
|
|
};
|
|
|
|
// fermeture du fichier .info
|
|
void UtilLecture::fermeture_pointInfo()
|
|
{ if (ptrcommandefich!= NULL) {delete ptrcommandefich;ptrcommandefich=NULL;}
|
|
};
|
|
|
|
// fermeture du fichier SchemaXML
|
|
void UtilLecture::fermetureSchemaXML()
|
|
{ if (ptrschemaXMLfich!= NULL) {delete ptrschemaXMLfich;ptrschemaXMLfich=NULL;}
|
|
};
|
|
|
|
// ouverture du fichier de copie des infos lue par le programme
|
|
void UtilLecture::OuvrirCopie()
|
|
{ char noml[132];
|
|
char*fileName = noml;
|
|
|
|
strcpy(fileName, pteurnom);
|
|
copie = new ofstream(strcat(fileName,".copie"));
|
|
|
|
if(!(copie->is_open()))
|
|
{ cout << "\n erreur en ouverture du fichier de copie " << fileName << endl;
|
|
Sortie(1);
|
|
};
|
|
};
|
|
//fermeture du fichier de copie des infos lue par le programme
|
|
void UtilLecture::FermerCopie()
|
|
{ delete copie;
|
|
};
|
|
|
|
// lecture d'une nouvelle ligne de donnee utilisable pour l'entree de donnee
|
|
void UtilLecture::NouvelleDonnee()
|
|
{
|
|
int indicboucle = 0; // indicateur pour sortir de la boucle globale
|
|
int indicfichier = 0 ; // indicateur pour la fermeture de fichier
|
|
try
|
|
{
|
|
while (indicboucle == 0)
|
|
{
|
|
Nouvel_enreg(); // lecture d'un enreg ds le fichier courant
|
|
char* pentree ; // position du carractere "<"
|
|
pentree = strchr(tablcar,'<'); // position eventurelle de "<"
|
|
if ( pentree != NULL)
|
|
{ pentree++;NouveauFichier(pentree); }
|
|
else
|
|
{ indicboucle = 1; };
|
|
};
|
|
// on repositionne le flot au debut du tableau de carractere
|
|
// ouverture du flot a la longueur sans blanc
|
|
delete entree;
|
|
#ifndef ENLINUX_STREAM
|
|
entree = new istringstream(tablcar,strlen (tablcar)) ;
|
|
#else
|
|
entree = new istrstream(tablcar,(long)strlen (tablcar)) ;
|
|
#endif
|
|
}
|
|
// sortie normale du programme
|
|
catch (ErrNouvelEnreg erreur)
|
|
{ if ( erreur.lecture == 1) // on a atteind une fin de fichier
|
|
{ int indic; FermetureFichier(indic);
|
|
if (indic == 0) // cas ou il reste encore un fichier ouvert
|
|
{ NouvelleDonnee(); // appel recursif de la lecture
|
|
// on repositionne le flot au debut du tableau de carractere
|
|
// ouverture du flot a la longueur sans blanc
|
|
delete entree;
|
|
#ifndef ENLINUX_STREAM
|
|
entree = new istringstream(tablcar,strlen (tablcar)) ;
|
|
#else
|
|
entree = new istrstream(tablcar,(long)strlen (tablcar)) ;
|
|
#endif
|
|
}
|
|
else
|
|
throw (ErrNouvelleDonnee(1)); // fin de tous les fichiers atteind
|
|
}
|
|
else
|
|
throw (ErrNouvelleDonnee(-1)); // erreur en fermeture de fichier
|
|
}
|
|
};
|
|
|
|
|
|
// idem avec la méthode NouvelleDonnee()
|
|
// mais sans ouverture de fichier automatique
|
|
// le signe < est conservé dans la ligne
|
|
void UtilLecture::NouvelleDonneeSansInf()
|
|
{
|
|
int indicboucle = 0; // indicateur pour sortir de la boucle globale
|
|
int indicfichier = 0 ; // indicateur pour la fermeture de fichier
|
|
try
|
|
{
|
|
while (indicboucle == 0)
|
|
{
|
|
Nouvel_enreg(); // lecture d'un enreg ds le fichier courant
|
|
indicboucle = 1;
|
|
};
|
|
// on repositionne le flot au debut du tableau de carractere
|
|
// ouverture du flot a la longueur sans blanc
|
|
delete entree;
|
|
#ifndef ENLINUX_STREAM
|
|
entree = new istringstream(tablcar,strlen (tablcar)) ;
|
|
#else
|
|
entree = new istrstream(tablcar,(long)strlen (tablcar)) ;
|
|
#endif
|
|
}
|
|
// sortie normale du programme
|
|
catch (ErrNouvelEnreg erreur)
|
|
{ if ( erreur.lecture == 1) // on a atteind une fin de fichier
|
|
{ int indic; FermetureFichier(indic);
|
|
if (indic == 0) // cas ou il reste encore un fichier ouvert
|
|
{ NouvelleDonnee(); // appel recursif de la lecture
|
|
// on repositionne le flot au debut du tableau de carractere
|
|
// ouverture du flot a la longueur sans blanc
|
|
delete entree;
|
|
#ifndef ENLINUX_STREAM
|
|
entree = new istringstream(tablcar,strlen (tablcar)) ;
|
|
#else
|
|
entree = new istrstream(tablcar,(long)strlen (tablcar)) ;
|
|
#endif
|
|
}
|
|
else
|
|
throw (ErrNouvelleDonnee(1)); // fin de tous les fichiers atteind
|
|
}
|
|
else
|
|
throw (ErrNouvelleDonnee(-1)); // erreur en fermeture de fichier
|
|
};
|
|
};
|
|
|
|
// Retour du flot au debut de l'enregistrement
|
|
void UtilLecture::FlotDebutDonnee()
|
|
{// on repositionne le flot au debut du tableau de carractere
|
|
delete entree;
|
|
#ifndef ENLINUX_STREAM
|
|
entree = new istringstream(tablcar,strlen (tablcar)) ;
|
|
#else
|
|
entree = new istrstream(tablcar,(long) strlen (tablcar)) ;
|
|
#endif
|
|
};
|
|
|
|
// ecriture d'un message d'erreur du a une mauvaise lecture
|
|
void UtilLecture::ErreurLecture
|
|
(UtilLecture::ErrNouvelleDonnee erreur,char* message)
|
|
{ cout << "\n***** erreur en lecture *********"<< '\n';
|
|
cout << message << '\n';
|
|
if ( erreur.lecture == 1)
|
|
{ cout << " fin de fichier atteinte" << '\n'; }
|
|
else if ( erreur.lecture == -1 )
|
|
{ cout << "erreur de lecture \n";}
|
|
else
|
|
cout << " cas non prevu\n " ;
|
|
cout << " contenu de la ligne courante filtree lue " << tablcar << '\n';
|
|
cout << " contenu de la ligne courante non filtree lue " << tableau << '\n';
|
|
cout << "racine du fichier principal = " << nomRacine << '\n';
|
|
cout << " fichier courant ouvert en lecture = " << nomCourant << '\n';
|
|
cout << " numero de la ligne courante = " << maille1->numLigne << '\n';
|
|
cout << endl;
|
|
};
|
|
// ecriture d'un message et du contenu des buffers courant
|
|
void UtilLecture::MessageBuffer(string message)
|
|
{
|
|
cout << "\n****** " << message << "******** " << '\n';
|
|
cout << "\n** information sur les buffers **"<< '\n';
|
|
cout << " contenu de la ligne courante filtree lue = " << tablcar << '\n';
|
|
cout << " contenu de la ligne courante non filtree lue = " << tableau << '\n';
|
|
cout << "racine du fichier principal = " << nomRacine << '\n';
|
|
cout << " fichier courant ouvert en lecture = " << nomCourant << '\n';
|
|
if (maille1 != NULL)
|
|
cout << " numero de la ligne courante = " << maille1->numLigne << '\n';
|
|
cout << endl;
|
|
};
|
|
|
|
// recherche d'une chaine de carractere pointee par nom
|
|
void UtilLecture::Cherche(const char * nom)
|
|
{ do { NouvelleDonnee(); }
|
|
while(strstr(tablcar,nom)==NULL);
|
|
};
|
|
|
|
// ouverture d'un nouveau fichier
|
|
void UtilLecture::NouveauFichier(char* ptr)
|
|
{
|
|
ifstream * sPtr = ptrfich; // sauve de l'adresse
|
|
|
|
// passage des carracteres "espace" eventuelle
|
|
int fii = 1;
|
|
while((*ptr == ' ')&&(fii<longueur)) {fii++; ptr++;};
|
|
|
|
ptrfich = new ifstream(ptr); // ouverture d'un nouveau fichier
|
|
nomCourant = ptr;
|
|
|
|
// gestion d'erreur d'ouverture non admise pour la suite du programme
|
|
if(!(ptrfich->is_open()))
|
|
{ if (ParaGlob::Francais())
|
|
{cout << " cas d'un fichier decrit par la commande < " << '\n'
|
|
<< " erreur en ouverture du fichier = " << (string(ptr)) << endl;
|
|
}
|
|
else
|
|
{cout << " case of an include file, introduced by the command < " << '\n'
|
|
<< " error in opening the file = " << (string(ptr)) << endl;
|
|
};
|
|
Sortie(1);
|
|
};
|
|
|
|
|
|
// ajout d'un maillon a la liste chainee d'ouverture de fichier
|
|
PointFich* poi = maille1;
|
|
maille1 = new PointFich (poi,sPtr,nomCourant);
|
|
|
|
};
|
|
|
|
|
|
// fermeture d'un fichier
|
|
void UtilLecture::FermetureFichier(int& indic)
|
|
{
|
|
// retour sur le fichier precedent si possible
|
|
if (maille1->t1 != NULL)
|
|
{
|
|
delete ptrfich; //fermeture du fichier
|
|
ptrfich = maille1->sauvePtr; // recup de l'adresse fichier
|
|
PointFich* poi = maille1->t1; // sauve adresse precedente
|
|
delete maille1; // suppression de la maille courante
|
|
maille1 = poi; // et pointage sur la maille precedente
|
|
nomCourant = maille1->nom; // mise a jour du nomcourant de fichier ouvert
|
|
|
|
indic = 0; // operation reussie
|
|
}
|
|
else
|
|
indic = 1; // fin des fichiers intermediaires atteinte
|
|
};
|
|
|
|
|
|
// affichage sur la sortie standard de l'enregistrement courant
|
|
void UtilLecture::AfficheEnreg () const
|
|
{ cout << tablcar << '\n';
|
|
};
|
|
|
|
// entrée par argument au niveau de la construction de l'objet UtilLecture
|
|
// dans le cas où il y a eu un pb lec_ent_info=-100, et rien n'est initialisé
|
|
bool UtilLecture::EntreeParArgument(int argc, const char * argv[])
|
|
{ // on regarde maintenant s'il y a passage par arguments
|
|
// le premier argument est le nom du programme qui est lancé (semblerait-il)
|
|
// donc se qui nous intéresse c'est les arguments suivants
|
|
bool entree_par_argument=false;
|
|
// par défaut on signale que l'on est en mode de demande de renseignement d'UtilLecture
|
|
// mais rien n'est initialisé, il faut arrêter
|
|
if (argc > 1)
|
|
lec_ent_info=-100; // initialisation par défaut
|
|
// === cas où il y a qu'un seul argument ===
|
|
if (argc==2)
|
|
{int i=1;entree_par_argument=true;
|
|
if (argv[i][1]=='f') // -- cas d'une entrée par fichier, il faudrait un second argument
|
|
{ cout << "\n usage: -f <nom_fichier_entree>" << endl; }
|
|
else if (argv[i][1]=='n') // -- cas de la construction d'un fichier, il faudrait un second argument
|
|
{ cout << "\n usage: -n <nom_fichier_sortie(sans le .info)>" << endl; }
|
|
else if (argv[i][1]=='x') // -- cas de la construction du shema xml d'entree de donnees
|
|
{ entree_par_argument=true;
|
|
lec_ent_info = -12;
|
|
nomRacine="Herezhpp"; // nom prédéterminé
|
|
}
|
|
else if (argv[i][1]=='u') // -- cas de l'utilisation d'herezh sous forme d'une procédure umat abaqus
|
|
// il faudrait un autre argument
|
|
{ cout << "\n usage: -uf <nom_fichier_entree>" << endl; }
|
|
else if (argv[i][1]=='h') // -- cas du rappel de l'usage
|
|
{ cout << "\n usage: HZpp -[fnxh] <fichier>"
|
|
<< "\n -h rappel de l'usage"
|
|
<< "\n -f execution avec le fichier de commande qui suit"
|
|
<< "\n -x creation du schema XML pour fichier de commande: Herezhpp.xsd"
|
|
<< "\n -n creation interactive d'un fichier de commande";
|
|
}
|
|
}
|
|
else // === cas où il y a plusieurs arguments ===
|
|
{for (int i=1;i< argc;i++)
|
|
{if (argv[i][1]=='f') // -- cas d'une entrée par fichier
|
|
{if(i<argc-1)
|
|
{ i++;
|
|
entree_par_argument=true;
|
|
lec_ent_info = 0;
|
|
string motinter(argv[i]); // on récupère en string
|
|
nomRacine=motinter; // copie
|
|
// dans le cas où ".info" figure dans la racine, on supprime cette chaine
|
|
int posi = nomRacine.find(".info");
|
|
if (posi != string::npos)
|
|
{ string nom_inter = nomRacine.substr(0,posi);
|
|
nomRacine = nom_inter;
|
|
};
|
|
}
|
|
else
|
|
{ cout << "\n usage: -f <nom_fichier_entree>" << endl; }
|
|
break; // pour l'instant une seule passe
|
|
}
|
|
else if (argv[i][1]=='n') // -- cas de la construction d'un fichier
|
|
{if(i<argc-1)
|
|
{ i++;
|
|
entree_par_argument=true;
|
|
lec_ent_info = -11;
|
|
string motinter(argv[i]); // on récupère en string
|
|
nomRacine=motinter; // copie
|
|
// dans le cas où ".info" figure dans la racine, on supprime cette chaine
|
|
int posi = nomRacine.find(".info");
|
|
if (posi != string::npos)
|
|
{ string nom_inter = nomRacine.substr(0,posi);
|
|
nomRacine = nom_inter;
|
|
};
|
|
}
|
|
else
|
|
{ cout << "\n usage: -n <nom_fichier_sortie(sans le .info)>" << endl; }
|
|
break; // pour l'instant une seule passe
|
|
}
|
|
else if (argv[i][1]=='x') // -- cas de la construction d'un shema xml d'entree de donnees
|
|
{ cout << "\n usage: -x " << endl;
|
|
break;
|
|
}
|
|
else if (argv[i][1]=='h') // -- cas du rappel de l'usage
|
|
{ cout << "\n usage: HZpp -[fnxh] <fichier>"
|
|
<< "\n -h rappel de l'usage"
|
|
<< "\n -f execution avec le fichier de commande qui suit"
|
|
<< "\n -x creation d'un schema XML pour fichier de commande: Herezhpp.xsd"
|
|
<< "\n -n creation interactive d'un fichier de commande";
|
|
break; // pour l'instant une seule passe
|
|
}
|
|
};
|
|
};
|
|
// retour
|
|
return entree_par_argument;
|
|
};
|
|
|
|
// entrée interactive au niveau de la construction de l'objet UtilLecture
|
|
// dans le cas où il y a eu un pb lec_ent_info=-100, et rien n'est initialisé
|
|
void UtilLecture::EntreeInteractive(string& ancien,bool& ouverture_ancien)
|
|
{ // entrée interactive
|
|
if (!ouverture_ancien)
|
|
// pas de possibilité d'utilisation de racine déjà existante
|
|
{ nomRacine = "";
|
|
while (!((nomRacine.length () != 0) ||
|
|
(nomRacine == "1") || (nomRacine == "2")))
|
|
{ cout << "\n pb en ouverture en lecture du fichier : ancien"
|
|
<< " , on continu quand meme ";
|
|
cout << "\n entrer la racine du nom du fichier .info :\n"
|
|
<< " ou repondre 1 pour une entree via le fichier base-info\n"
|
|
<< " ou repondre 2 pour une entree via un serveur base-info\n"
|
|
<< " ou repondre x pour la creation d'un schema XML pour creer\n"
|
|
<< " un fichier de commade: Herezhpp.xsd\n"
|
|
<< " ou repondre n pour la construction d'un nouveau fichier de commande\n";
|
|
nomRacine= lect_chaine();
|
|
if (nomRacine == "1")
|
|
lec_ent_info = 1;
|
|
else if (nomRacine == "2")
|
|
lec_ent_info = 2;
|
|
else if (nomRacine == "n")
|
|
{lec_ent_info = -11;
|
|
cout << "\n entrer la racine du nom du fichier de commande a cree : \n";
|
|
nomRacine= lect_chaine();
|
|
}
|
|
else if (nomRacine == "x")
|
|
{lec_ent_info = -12;
|
|
cout << "\n ====================================== \n";
|
|
cout << "\n $$$$$ construction du schema XML $$$$ \n";
|
|
cout << "\n $$$$$ fichier: Herezhpp.xsd $$$$ \n";
|
|
cout << "\n ====================================== \n";
|
|
nomRacine="Herezhpp";
|
|
}
|
|
else
|
|
lec_ent_info = 0;
|
|
}
|
|
}
|
|
else
|
|
// utilisation de la racine existante
|
|
{ nomRacine = "";
|
|
while (!((nomRacine.length () != 0) || (nomRacine == "0") || (nomRacine == "o")
|
|
|| (nomRacine == "1") || (nomRacine == "2")))
|
|
{ cout << "\n entrer la racine du nom du fichier .info : (" << ancien <<").info \n"
|
|
<< " ou repondre o ou 0 si l'on veut l'ancien nom \n"
|
|
<< " ou repondre 1 pour une entree via le fichier base-info\n"
|
|
<< " ou repondre 2 pour une entree via un serveur base-info\n"
|
|
<< " ou repondre x pour la creation d'un schema XML pour creer\n"
|
|
<< " un fichier de commade: Herezhpp.xsd\n"
|
|
<< " ou repondre n pour la construction d'un nouveau fichier de commande\n";
|
|
nomRacine= lect_chaine();
|
|
if (nomRacine == "1")
|
|
lec_ent_info = 1;
|
|
else if (nomRacine == "2")
|
|
lec_ent_info = 2;
|
|
else if ((nomRacine == "0")||(nomRacine == "o"))
|
|
{ lec_ent_info = 0;
|
|
nomRacine = ancien;
|
|
}
|
|
else if (nomRacine == "n")
|
|
{lec_ent_info = -11;
|
|
cout << "\n entrer la racine du nom du fichier de commande a cree : \n";
|
|
nomRacine= lect_chaine();
|
|
}
|
|
else if (nomRacine == "x")
|
|
{lec_ent_info = -12;
|
|
cout << "\n ====================================== \n";
|
|
cout << "\n $$$$$ construction du schema XML $$$$ \n";
|
|
cout << "\n $$$$$ fichier: Herezhpp.xsd $$$$ \n";
|
|
cout << "\n ====================================== \n";
|
|
nomRacine="Herezhpp";
|
|
}
|
|
else if (nomRacine.length () != 0)
|
|
lec_ent_info = 0;
|
|
}
|
|
};
|
|
// dans le cas où ".info" figure dans la racine, on supprime cette chaine
|
|
int posi = nomRacine.find(".info");
|
|
if (posi != string::npos)
|
|
{ string nom_inter = nomRacine.substr(0,posi);
|
|
nomRacine = nom_inter;
|
|
};
|
|
|
|
};
|
|
|
|
//------------- utilitaires de lecture d'une grandeurs qui peut-être une constante utilisateur ---
|
|
|
|
|
|
double UtilLecture::lect_avec_const_double_utilisateur(string nom_erreur) const
|
|
{string nom;
|
|
double val; // le retour
|
|
*entree >> nom ;
|
|
// on regarde si les 3 premières lettres sont C__
|
|
if ((nom[0]== 'C')&&(nom[1]== '_')&&(nom[2]== '_'))
|
|
// il s'agit d'une constante utilisateur, on récupère sa valeur
|
|
{
|
|
// on récupère le pointeur correspondant à la grandeur
|
|
const void* pointe = (ParaGlob::param->GrandeurGlobal(nom));
|
|
if (pointe != NULL)
|
|
{TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
|
|
if ((gr_quelc->Grandeur_pointee()->Type_structure_grandeurAssocie()==TYPE_SIMPLE)
|
|
&& (gr_quelc->Grandeur_pointee()->Type_enumGrandeurParticuliere()==PARTICULIER_SCALAIRE_DOUBLE)
|
|
)
|
|
{val = gr_quelc->Grandeur_pointee()->GrandeurNumOrdre(1);
|
|
}
|
|
else // sinon pb
|
|
{ cout << "\n *** pb dans dans l'utilisation de la constante globale "<< nom
|
|
<< " le conteneur lu " << nom << " n'est pas d'un type correct !! "
|
|
<< "\n >>> lecture : " << nom_erreur;
|
|
if (ParaGlob::NiveauImpression() > 3)
|
|
cout << "\n UtilLecture::Lect_avec_const_double_utilisateur(...";
|
|
Sortie(1);
|
|
};
|
|
}
|
|
else // sinon pb
|
|
{ cout << "\n *** erreur dans l'utilisation de la constante globale "<< nom
|
|
<< " la variable n'existe pas !! "
|
|
<< "\n >>> lecture : " << nom_erreur
|
|
<< "\n >>> lecture : " << nom_erreur;
|
|
if (ParaGlob::NiveauImpression() > 3)
|
|
cout << "\n UtilLecture::Lect_avec_const_double_utilisateur(...";
|
|
Sortie(1);
|
|
};
|
|
|
|
}
|
|
else // c'est directement une valeur, on traduit
|
|
{val = ChangeReel(nom);};
|
|
// retour de la valeur
|
|
return val;
|
|
};
|
|
|
|
|
|
// modification interactive d'une constante utilisateur
|
|
// la constante doit déjà exister
|
|
void UtilLecture::Modif_interactive_constante_utilisateur()
|
|
{
|
|
try
|
|
{string nom;
|
|
cout << "\n nom de la constante utilisateur a modifier ? ";
|
|
cin >> nom ;
|
|
cout << " (nom lu: "<< nom << ") ";
|
|
// on regarde si les 3 premières lettres sont C__
|
|
if ((nom[0]== 'C')&&(nom[1]== '_')&&(nom[2]== '_'))
|
|
// il s'agit d'une constante utilisateur, on récupère sa valeur
|
|
{
|
|
// on récupère le pointeur correspondant à la grandeur
|
|
const void* pointe = (ParaGlob::param->GrandeurGlobal(nom));
|
|
if (pointe != NULL)
|
|
{TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
|
|
// récup du typeQuelconque
|
|
const TypeQuelconque_enum_etendu& enu = gr_quelc->EnuTypeQuelconque();
|
|
if (enu == GENERIQUE_UNE_CONSTANTE_GLOB_DOUBLE_UTILISATEUR)
|
|
{if ((gr_quelc->Grandeur_pointee()->Type_structure_grandeurAssocie()==TYPE_SIMPLE)
|
|
&& (gr_quelc->Grandeur_pointee()->Type_enumGrandeurParticuliere()==PARTICULIER_SCALAIRE_DOUBLE)
|
|
)
|
|
{// valeur initiale
|
|
double val_init = gr_quelc->Grandeur_pointee()->GrandeurNumOrdre(1);
|
|
// lecture de la nouvelle valeur
|
|
double nevezval;
|
|
cout << "\n valeur actuelle " << val_init
|
|
<< " nouvelle valeur ? " ;
|
|
cin >> nevezval;
|
|
if (ParaGlob::NiveauImpression() > 0)
|
|
{cout << "\n modification de la constante utilisateur : "<< nom;
|
|
cout << " ancienne valeur " << val_init;
|
|
cout << " nouvelle valeur lue "<< nevezval ;
|
|
};
|
|
ParaGlob::param->Mise_a_jour_grandeur_consultable_Scalaire_double(nom,nevezval);
|
|
}
|
|
else // sinon pb
|
|
{ cout << "\n *** pb dans dans la modification de la constante utilisateur "<< nom
|
|
<< " le conteneur lu " << nom << " n'est pas d'un type correct !! ";
|
|
if (ParaGlob::NiveauImpression() > 3)
|
|
cout << "\n UtilLecture::Modif_interactive_constante_utilisateur(...";
|
|
Sortie(1);
|
|
};
|
|
}
|
|
else // cas ou on a détecter que la grandeur globale n'est pas une constante utilisateur
|
|
{ cout << "\n *** erreur dans l'utilisation de la grandeur globale "<< nom
|
|
<< " ce n'est pas une constante utilisateur !! "
|
|
<< " *** on ne change rien " ;
|
|
if (ParaGlob::NiveauImpression() > 3)
|
|
cout << "\n UtilLecture::Modif_interactive_constante_utilisateur(...";
|
|
cout <<flush;
|
|
};
|
|
}
|
|
else // cas ou la constante n'existe pas
|
|
{ cout << "\n *** erreur dans l'utilisation de la constante utilisateur "<< nom
|
|
<< " la variable n'existe pas !! "
|
|
<< " *** on ne change rien " ;
|
|
if (ParaGlob::NiveauImpression() > 3)
|
|
cout << "\n UtilLecture::Modif_interactive_constante_utilisateur(...";
|
|
cout <<flush;
|
|
};
|
|
|
|
}
|
|
else //cas ou ce n'est pas une constante utilisateur
|
|
{cout << "\n *** erreur en lecture d'une constante utilisateur "<< nom
|
|
<< " la variable doit commencer par C__ !! "
|
|
<< " et on a lue : " << nom
|
|
<< " *** on ne change rien " ;
|
|
if (ParaGlob::NiveauImpression() > 3)
|
|
cout << "\n UtilLecture::Modif_interactive_constante_utilisateur(...";
|
|
cout <<flush;
|
|
};
|
|
}
|
|
// sortie anormale normale du programme
|
|
catch (ErrSortieFinale)
|
|
// cas d'une direction voulue vers la sortie
|
|
// on relance l'interuption pour le niveau supérieur
|
|
{ ErrSortieFinale toto;
|
|
throw (toto);
|
|
}
|
|
catch (...)
|
|
{cout << "\n *** erreur inconnue en modification d'une constante utilisateur "
|
|
<< " *** on ne change rien " ;
|
|
if (ParaGlob::NiveauImpression() > 3)
|
|
cout << "\n UtilLecture::Modif_interactive_constante_utilisateur(...";
|
|
cout <<flush;
|
|
};
|
|
|
|
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
|
|
|
|
};
|
|
|