/tmp/galet/src/galet.cpp

Aller à la documentation de ce fichier.

// vim:syntax=cpp.doxygen tw=3 sw=3
/***************************************************************************
 *   Copyright (C) 2008 by Brice Boyer                                     *
 *   brice.boyer@ens-lyon.org                                              *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This 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, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <iostream>
#include <cstdlib>

#include "type_base.h"
#include "explore.h"
#include "graphe.h"
#include "parseur.h"

using namespace std;

//int GN_ = 0 ;

/* init static */

entier_type       GRAPHE::_NombreImpr = 0  ;
entier_type       GRAPHE::_NombreCree  = 0  ;
entier_type       GRAPHE::_MaTaille = 0  ;
noms_type         GRAPHE::_NomsNoeuds ;
bool              GRAPHE::_AReussi = false;
bool              GRAPHE::_CopieOk = false;                    // par défaut, on n'a pas droit à la copie.
noms_type         GRAPHE::_NomsOpers  ;
//relatif_matrix  GRAPHE::opers_incid ;
relatif_vect      GRAPHE::_OpersProp  ;
relatif_matrix    GRAPHE::_OpersOrdre ;
oper_vect         GRAPHE::_Operations  ;
entier_type       GRAPHE::_GaletMax   ;

/* MAIN */

void aide (const etiquette & nomprog) {
   cout << _ok << "Usage :\n";
   cout << '\t' << nomprog << "-opt1 toto [-opt_opt2 titi] --choix1 --choix2 ... fichier\n";
   cout << _ok << "Options :\n";
   cout << "-g x \t: on peut utiliser x galets. Par défaut le nombre d'initiaux.\n";
   cout << _ok << "Options optionnelles :\n";
   cout << "-o y \t: la sortie est y; (NE PAS JOUER AVEC ÇA)\n";
   cout << "-h\t : cette aide !\n";
   cout << _ok << "Choix :\n";
   cout << "--toutes-sols \t: on veut toutes les solutions (PAS TOUT À FAIT IMPLÉMENTÉ) ;\n";
   cout << "--avec-copie  \t: on autorise le copiage.\n";
   cout << "--cherche-sol \t : on cherche le nombre minimum de galets (PAS TESTÉ, NE PAS UTILISER).\n";
   cout << _ok << "Par défaut:\n";
   cout << "On n'utilise pas le copiage et on veut savoir s'il y a une solution pour le nombre mini de galet possible.\n";
   cout << "Le nom de fichier est par défaut ./arbre/arbre.dat\n\n";
   cout << _ok << "Pour modifier le niveau de débogage, aller regarder dans src/type_base.h la macro NIVEAU_DEBUG.\n\n";
   cout << _ok << "exemple d'utilisation : ./galet -g 14 --avec-copie ./arbre/Wino.dat \n";
   cout << "La syntaxe des arbres est documentée quelque part\n\n";
   return;
}

int main ( int argc, char *argv[] ) {

   string entree_default = "./arbre/arbre.dat"; // fichier d'entrée par défaut.
   /*** on parse ***/

   string nomprog    = argv[0];
   bool on_copie     = false;                                           // par défaut, on ne copie pas
   bool toutes_sols  = false;                                           // on cherche si galéisable
   bool cherche_min  = false;                                           // et on ne cherche pas la meilleur sol.
   unsigned nb_galets = 0;                                              // par défaut on ne sais pas combien de galet on cherche.
   ostringstream sortie ;                                               // inutile.
   ostringstream entree ;
   if ( argc == 1 ) {
      cout << "on utilise les options par défaut.\n";
   }
   else {
      unsigned i = 1 ;
      while ( i < (unsigned) argc  ) {                                  /*{{{*/
         if ( argv[i][0] == '-' ) {                                     /*{{{*/
            switch (argv[i][1]) {
               case 'g' : {                                             // galets
                  nb_galets = atoi(argv[i+1]);
                  if ( nb_galets < 1 || nb_galets > 90 ) {
                     cout << _erreur << "Dans la fonction " << nomprog << ", l'argument " << argv[i][2] << " de " << argv[i] << " est incorrect.\n";
                     aide ( nomprog );
                     return ( EXIT_FAILURE );
                  }
                  i += 2;
               }
               break;
               case 'o' : {
                  sortie << argv[i+1] ;                                 // faut être tordu pour dire -o toto -o titi non ?
                  i += 2;
               }
               case '?' :
               case 'h' : {
                  aide( nomprog );
                  return (EXIT_SUCCESS);
               }
               break;
               case '-' : {
                  switch (argv[i][2]) {
                     case 't' : {
                        toutes_sols = true;
                     }
                     break;
                     case 'a' : {
                        on_copie = true;
                     }
                     break;
                     default : {
                        cout << _erreur << "fonction " << nomprog << " : argument de " << argv[i] << " incorrect.\n";
                        aide ( nomprog ) ;
                        return ( EXIT_FAILURE ) ;
                     }
                     case 'h' : {
                        aide(nomprog);
                        return (EXIT_SUCCESS);
                     }
                  }
                  ++i;
               }
               break;
               default :  {
                  cout << _erreur << "fonction " << nomprog << " : argument de " << argv[i] << " incorrect.\n";
                  aide ( nomprog );
                  return ( EXIT_FAILURE );
               }
            }
         }                                                              // fin '-'/*}}}*/
         else {/*{{{*/
            entree << argv[i];                                          // c'est qui qui lancerait prog -a x toto -b y toto -a t toto ???
            entree_default = entree.str();
            ++i;
         }                                                              // fin dernier/*}}}*/
      }                                                                 // fin/*}}}*/
   }                                                                    // argc != 1

   /*** on a fini de parser !! ***/
   cout << "On a lu :\n";
   cout << "-g \t"            << nb_galets     << endl ;
   cout << "-o \t"            << sortie.str()  << endl ;
   cout << "--toutes-sols\t"  << LaReponse(toutes_sols)   << endl ;
   cout << "--avec-copie\t"   << LaReponse(on_copie)      << endl ;
   cout << "entrée : \t"      << entree.str()  << endl ;