#include <applicat.h>
#include <automask.h>
#include <isam.h>
#include <mask.h>
#include <prefix.h>
#include <progind.h>
#include <relation.h>
#include <sheet.h>
#include <tabutil.h>

#include <nditte.h>

#include "ce0.h"
#include "ce0900a.h"
#include "../cg/cglib01.h"

#define CAMPODITTA "CAMPODITTA"

class TConversione_ce_mask : public TAutomask
{
  TRelation*      _rel;
  TCursor*        _cur;
  TCursor_sheet*  _sheet;
     
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
     
public:
  TCursor_sheet& sheet() {return *_sheet;}
  void lista_ditte(TAssoc_array& ditte);
  TConversione_ce_mask(); 
  ~TConversione_ce_mask();
};  
                                                          
static bool esiste_ditta(const TRelation* rel)
{                        
  const long ditta = rel->curr().get_long(NDT_CODDITTA);
  return prefix().exist(ditta);
}                                                                              
   
bool TConversione_ce_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
  case F_SCELTADITTE:
    if (e == fe_button)
    {
      sheet().run();
      set(F_DITTESELEZ, sheet().checked());
    } 
    if (e == fe_close)
      if (sheet().checked() == 0)
        return error_box("Non sono state selezionate ditte da convertire");
    break;
  case F_DITTESELEZ:
    if (e == fe_init)
      o.set(sheet().checked());
    break;    
  case F_MINISTERIALI:
    if (e == fe_init)
    {
      TTable cgr("%CGR");     
      const bool empty = cgr.first() != NOERR;
      o.set(empty ? "X": " ");
    }
    break;    
  default:
    break;
  }     
  return TRUE;
}  

void TConversione_ce_mask::lista_ditte(TAssoc_array& ditte)
{
  ditte.destroy();
  for (long i = sheet().items()-1; i >= 0; i--)
  {                                           
    if (sheet().checked(i))
    {
      const char* codditta = sheet().row(i).get(1);
      ditte.add(codditta);
    }  
  }
}    
   
TConversione_ce_mask::TConversione_ce_mask()
: TAutomask("ce0900a")
{
  _rel = new TRelation(LF_NDITTE);
  _cur = new TCursor(_rel); 
  _cur->set_filterfunction(esiste_ditta);
  _sheet = new TCursor_sheet(_cur, " |CODDITTA|RAGSOC", "Selezione ditte", "@1|Codice|Ragione sociale@50", 0, 1);
  _sheet->check(-1);
}

TConversione_ce_mask::~TConversione_ce_mask()
{
  delete _sheet;
  delete _cur;
  delete _rel;
}

class TConversione_cespiti: public TSkeleton_application
{
  FILE * _log;
  TAssoc_array  _ditte;
  
protected:
  virtual bool create(void);
  virtual void main_loop();
  virtual bool destroy(void) ;
  void open_log();
  void write_log(const char * line);
  void close_log();
  int zap_file(int lf) const;
public:
  bool daconvertire(const long ditta);
  int conv_file(const TFilename& ofname, int nflogicnum);
  int conv_inifile(const TFilename& ofname, const char* ofpar, int nflogicnum);
  int conv_tab(const TFilename& ofname, const char* cod);
  int conv_par(const TFilename& ofname, const char* ofpar, int which_config);
  int get_codesc(const TDate& date, const bool fatal = TRUE);
  const char conv_imptmc(int cod);
  TConversione_cespiti() {}
  virtual ~TConversione_cespiti() {}
};

bool TConversione_cespiti::create()
{
  return TSkeleton_application::create();
}

bool TConversione_cespiti::destroy()
{
  return TSkeleton_application::destroy();
}
                                      
bool TConversione_cespiti::daconvertire(const long ditta)
{
  TString16 strditta;
  strditta.format("%ld", ditta);
  return _ditte.is_key(strditta); 
}                                      
                                      
void TConversione_cespiti::main_loop()
{  
  TConversione_ce_mask msk;                   
  if (msk.run() == K_ENTER) 
  {                      
    if (yesno_box("Confermare la conversione dei cespiti?"))
    {
      msk.lista_ditte(_ditte);
      open_log();
      TString80 s;
      write_log("");        
      write_log("**********************************");        
      s.format("Conversione cespiti del %s", (const char *) TDate(TODAY).string());
      write_log(s);
      write_log("**********************************");        
      write_log("");        
    
      const char* studio = prefix().get_studio();
      const bool converti_ministeriali  = msk.get_bool(F_MINISTERIALI);
      // conversione archivi
      TFilename file = studio;
      file << "cesp/ammce";
      conv_file(file, 136);
      file = studio;
      file << "cesp/ammmv";
      conv_file(file, 137);
      file = studio;
      file << "cesp/catdi";
      conv_file(file, 138);
      file = studio;
      file << "cesp/cespi";
      conv_file(file, 139);
      file = studio;
      file << "cesp/movam";
      conv_file(file, 141);
      file = studio;
      file << "cesp/movce";
      conv_file(file, 142);
      file = studio;
      file << "cesp/salce";
      conv_file(file, 143); 
      file = studio;
      file << "cesp/coll01";
      conv_inifile(file, "COLL01", 140); 
      // conversione tabelle
      file = studio;
      file << "cesp/ditcb";
      conv_tab(file, "CCB"); 
      file = studio;
      file << "cesp/ditce";
      conv_tab(file, "CCE"); 
      file = studio;
      file << "cesp/tabimp";
      conv_tab(file, "CIM"); 
      file = studio;
      file << "cesp/tabloc";
      conv_tab(file, "LOC"); 
      if (converti_ministeriali)
      { 
        file = studio;
        file << "cesp/tabat";
        conv_tab(file, "%CAT"); 
        file = studio;
        file << "cesp/tabca";
        conv_tab(file, "%CAC"); 
        file = studio;
        file << "cesp/tabgr";
        conv_tab(file, "%CGR"); 
        file = studio;
        file << "cesp/limit";
        conv_tab(file, "%CLM"); 
        file = studio;
        file << "cesp/tmvce";
        conv_tab(file, "%TMC"); 
      }
      // conversione parametri
      file = studio;
      file << "cesp/ditc01";
      conv_par(file, "DITC01", CONFIG_DITTA);
      file = studio;
      file << "cesp/ditca";
      conv_par(file, "DITCA", CONFIG_DITTA);
      message_box("Conversione completata");
      close_log();        
    }    
  }   
}

void TConversione_cespiti::open_log() 
{                  
  TFilename log;
  
  log << "ceconv.log";
  _log = fopen(log,"a");
  if (_log == NULL)
    fatal_box("Non posso aprire il file di log della conversione(%s)", (const char *) log);
}

void TConversione_cespiti::write_log(const char * line)
{         
  fprintf(_log,"%s\n", line);
}

void TConversione_cespiti::close_log()
{
  fclose(_log);
}

int TConversione_cespiti::conv_file(const TFilename& ofname, int nflogicnum)
{       
  long oldditta = -1;
  long ditta;
  TDir d;
  d.get(nflogicnum);
  d.eod() = 0L;
  d.put(nflogicnum);
//resetta i files di destinazione prima di scriverci sopra
  int err = zap_file(nflogicnum);
  if (err == NOERR)
  {
    TExternisamfile* oldfile = new TExternisamfile(ofname, FALSE, FALSE);
    TLocalisamfile* newfile = new TLocalisamfile(nflogicnum); 
    TRectype oldrec = oldfile->curr();
    TRectype newrec = newfile->curr();
    TProgind *pi;                                   
    TString80 message;
    message.format("Conversione tabella %s", (const char*) ofname);
    pi = new TProgind(oldfile->eod(),message, FALSE, TRUE, 10);
    pi->setstatus(1);
    
    bool to_convert = FALSE;
    for (int err = oldfile->first(); err == NOERR; err = oldfile->next())
    {                 
      pi->addstatus(1);
      // mi posiziono sulla ditta indicata
      ditta = oldfile->get_long("CODDITTA");               
      // i record sono ordinati per ditta!                                        
      if (oldditta != ditta)
      {
        oldditta = ditta;
        to_convert = daconvertire(ditta);
        if (to_convert)
          set_firm(ditta);                                        
        else                                                      
        {
          TString s;
          s.format("La ditta %ld indicata nel file %s non é stata selezionata per la conversione", ditta, (const char*) ofname);
          write_log(s);
        } 
      } 
      if (!to_convert)
        continue;
      
      // creo nuovo record        
      newrec.zero();    
      // setto i campi con lo stesso nome
      for (int i = 0; i < oldrec.items(); i++)
      {                                                          
        const char* fieldname = oldrec.fieldname(i);
        if (newrec.exist(fieldname))  
        {
          newrec.put(fieldname, oldfile->get(fieldname));
          if ((newrec.type(fieldname) != oldrec.type(fieldname)) && (newrec.type(fieldname)==_alfafld))
          {                       
            TString stringa = newrec.get(fieldname);
            stringa.right_just(newrec.length(fieldname),'0');
            newrec.put(fieldname, stringa);
          } 
        } 
      }
      // setto i campi che vanno elaborati pirsunalmente di pirsuna (nomi diversi)
      switch (nflogicnum)
      {
        case 136:
        {        
          TString80 codes;
          codes.format("%04d",get_codesc(oldfile->get_date("DTINES")));
          newrec.put("CODES", codes);
        }   
        break;
        case 138:
        {        
          TString80 codes;
          codes.format("%04d",get_codesc(oldfile->get_date("DTINES")));
          newrec.put("CODES", codes);
        }
        break;
        case 139:
        {
          newrec.put("CODCGRA", oldfile->get("AG0CGR"));
          newrec.put("CODSPA", oldfile->get("ATACSP"));
          newrec.put("CODCGR", oldfile->get("G0CGR"));
          newrec.put("CODSP", oldfile->get("TACSP"));
          newrec.put("CODCAT", oldfile->get("G0CCT"));
        }  
        break;
        case 142:
        {
          newrec.put("CODMOV", oldfile->get("TPMOV"));
          newrec.put("STAMPATO", oldfile->get("STBOLLATO"));
        }     
        break;
        case 143:
        {        
          TString8 codes;
          codes.format("%04d",get_codesc(oldfile->get_date("DTINES")));
          newrec.put("CODES", codes);
        }  
        break;
      } 
      // scrivo il record sul nuovo file
      int errore = newrec.write(*newfile);
    }              
    delete pi;
    delete newfile;
    delete oldfile;
  }
  else
    error_box("Errore in compattamento dati.\nFile %d : %d", nflogicnum,err);
  return 0;
}

int TConversione_cespiti::conv_tab(const TFilename& ofname, const char* tab)
{       
  long oldditta = -1;
  long ditta;
  TExternisamfile* oldfile = new TExternisamfile(ofname, FALSE, FALSE);
  const bool tabella_comune = (tab[0] == '%');
  TTable* newtab = new TTable(tab);  
  for (newtab->first(); !newtab->eof(); newtab->next()) 
    newtab->remove();
  delete newtab;  
  int err;  
  if (tabella_comune)
  {
    TSystemisamfile f(LF_TABCOM);
    err = f.pack();
  }
  else  
  {
    TSystemisamfile f(LF_TAB);
    err = f.pack();
  }
  if (err == NOERR)
  { 
    TTable* newfile = new TTable(tab);  
    TConfig config("ce0900.ini", tab);
    TAssoc_array& fieldlist = config.list_variables();
    TString16 campoditta = (TString&) config.get(CAMPODITTA);
    TString fieldname, fieldvalue;
    TRectype oldrec = oldfile->curr();
    TRectype newrec = newfile->curr();
    TProgind *pi;                                   
    TString80 message;
    message.format("Conversione tabella %s", (const char*) ofname);
    pi = new TProgind(oldfile->eod(),message, FALSE, TRUE, 10);
    pi->setstatus(1);
    for (int err = oldfile->first(); err == NOERR; err = oldfile->next())
    {                 
      pi->addstatus(1);
      if (tabella_comune)
        ditta = -1;
      else
        ditta = oldfile->get_long(campoditta);               
      // mi posiziono sulla ditta indicata
      // i record sono ordinati per ditta!                                        
      if (oldditta != ditta)
      {
        oldditta = ditta;
        if (daconvertire(ditta))
          set_firm(ditta);                                        
        else                                                      
        {
          TString256 s;
          s.format("La ditta %ld indicata nel file %s non é stata selezionata per la conversione", ditta, (const char*) ofname);
          write_log(s);
          continue;
        } 
      }
      // creo nuovo record        
      newrec.zero();    
      // setto i campi indicati                   
      FOR_EACH_ASSOC_STRING(fieldlist, obj, key, str)
      {                 
        fieldname = key;
        fieldvalue = str;
        if ((fieldname != CAMPODITTA) && (fieldvalue[0]!='!') && (fieldvalue[0]!='?'))
          newrec.put(key, oldfile->get(str));
        else
        {
          if (fieldvalue[0] == '?')
            newrec.put(key,fieldvalue.sub(1));
          else if (fieldvalue == "!_ESERCIZIO2")
          {
            TString80 codtab, tmp;
            codtab.format("%04d",get_codesc(oldfile->get_date("CBDTI")));
            tmp = oldfile->get("CBCGR");
            tmp.right_just(2,'0');
            codtab << tmp;
            tmp = oldfile->get("CBCSP");
            codtab << tmp;
            newrec.put(key, codtab);
          }
          else if (fieldvalue == "!_ESERCIZIO")
          {
            TString80 codtab;
            codtab.format("%04d",get_codesc(oldfile->get_date("CADTI")));
            newrec.put(key, codtab);
          }
          else if (fieldvalue == "!_CODIMP")
          {
            TString80 codtab;
            codtab.format("%10d",oldfile->get_long("CODIMP"));
            codtab.right_just(10,'0');
            newrec.put(key, codtab);
          }
          else if (fieldvalue == "!_CODLOC")
          {
            TString80 codtab;
            codtab.format("%10d",oldfile->get_long("CODLOC"));
            codtab.right_just(10,'0');
            newrec.put(key, codtab);
          }
          else if (fieldvalue == "!_CAT1")
          {
            TString16 codtab;
            const int gruppo = oldfile->get_int("TACGR");
            const TString16 specie(oldfile->get("TACSP"));
            codtab.format("%02d%s", gruppo,(const char*) specie);
            newrec.put(key, codtab);
          }
          else if (fieldvalue == "!_CAC1")
          {
            TString16 codtab;
            const int gruppo = oldfile->get_int("G0CGR");
            const TString16 specie(oldfile->get("TACSP"));
            const int categoria(oldfile->get_int("G0CCT"));
            if (gruppo == 0)
              codtab.format("      %02d",categoria);
            else
              codtab.format("%02d%-4s%02d", gruppo,(const char*) specie, categoria);
            newrec.put(key, codtab);
          }
          else if (fieldvalue == "!_CAC2")
          {
            TString80 codtab;
            int cod = oldfile->get_int("G0TCS");
            newrec.put(key, cod - 1);
          }
          else if (fieldvalue == "!_CLM1")
          {
            TString80 codtab;
            TDate data = oldfile->get_date("DTVALIM");
            codtab.format("%04d%2d%02d",data.year(),data.month(),data.day());
            newrec.put(key, codtab);
          }
          else if (fieldvalue == "!_CGR1")
          {
            TString80 codtab;
            codtab.format("%02d",oldfile->get_int("G0CGR"));
            newrec.put(key, codtab);
          }
          else if (fieldvalue == "!_TMC1")
          {
            TString80 cod = "";
            cod << conv_imptmc(oldfile->get_int("IMP01"));
            cod << " ";
            cod << conv_imptmc(oldfile->get_int("IMP03"));
            cod << conv_imptmc(oldfile->get_int("IMP04"));
            cod << conv_imptmc(oldfile->get_int("IMP05"));
            cod << conv_imptmc(oldfile->get_int("IMP06"));
            cod << conv_imptmc(oldfile->get_int("IMP07"));
            cod << conv_imptmc(oldfile->get_int("IMP08"));
            cod << conv_imptmc(oldfile->get_int("IMP09"));
            cod << conv_imptmc(oldfile->get_int("IMP10"));
            cod << conv_imptmc(oldfile->get_int("IMP11"));
            cod << conv_imptmc(oldfile->get_int("IMP12"));
            cod << conv_imptmc(oldfile->get_int("IMP13"));
            newrec.put(key, cod);
          }        
          else if (fieldvalue == "!_TMC2")
          {
            int num = oldfile->get_int("M0TTBL");
            TString16 cod;
            switch (num)
            {
              case 1:  
                cod = "I";
              break;  
              case 2:  
                cod = "E";
              break;  
              case 3:  
                cod = "P";
              break;  
              case 4:  
                cod = "R";
              break;  
              case 5:  
                cod = " ";
              break;  
              default:  
                cod = " ";
            }
            newrec.put(key, cod);
          }
          else if (fieldvalue == "!_TMC3")
          {
            TString16 cod;
            int num = oldfile->get_int("M0SEGN");
            switch (num)
            {
            case 1: 
              cod = "=";
            break;
            case 2:
              cod = "+";
            break;
            case 3:
              cod = "-";
            break;
            default:
            cod = " ";
            }
            newrec.put(key, cod);
          }  
          else if (fieldvalue == "!_CCE1")
          {
            TString16 cod;
            int num = oldfile->get_int("CATAR");
            switch (num)
            {
            case 1: 
              cod = "+";
            break;
            case 2:
              cod = "-";
            break;
            case 3:
              cod = "/";
            break;
            default:
            cod = " ";
            }
            newrec.put(key, cod);
          }
        } 
      }  
      // scrivo il record sul nuovo file
      int errore = newrec.write(*newfile);
    }  
    delete pi;
    delete newfile;
  }  
  delete oldfile;
  return 0;
}

int TConversione_cespiti::conv_inifile(const TFilename& ofname, const char* ofpar, int nflogicnum)
{       
  long oldditta = -1;
  long ditta;
  TDir d;
  d.get(nflogicnum);
  d.eod() = 0L;
  d.put(nflogicnum);
  TSystemisamfile f(nflogicnum);
  int err = f.pack();
  if (err == NOERR)
  {
    TExternisamfile* oldfile = new TExternisamfile(ofname, FALSE, FALSE);
    TLocalisamfile* newfile = new TLocalisamfile(nflogicnum);   
    TConfig config("ce0900.ini", (const char*) ofpar);
    TAssoc_array& fieldlist = config.list_variables();
    TString& campoditta = (TString&) config.get(CAMPODITTA);
    TString fieldname, fieldvalue;
    TRectype oldrec = oldfile->curr();
    TRectype newrec = newfile->curr();
    TProgind *pi;                                   
    TString80 message;
    message.format("Conversione tabella %s", (const char*) ofname);
    pi = new TProgind(oldfile->eod(),message, FALSE, TRUE, 10);
    pi->setstatus(1);
    for (int err = oldfile->first(); err == NOERR; err = oldfile->next())
    {                 
      pi->addstatus(1);
      // mi posiziono sulla ditta indicata
      ditta = oldfile->get_long(campoditta);               
      // i record sono ordinati per ditta!                                        
      if (oldditta != ditta)
      {
        oldditta = ditta;
        if (daconvertire(ditta))
          set_firm(ditta);                                        
        else            
        {
          TString256 s;
          s.format("La ditta %ld indicata nel file %s non é stata selezionata per la conversione", ditta, (const char*) ofname);
          write_log(s);
          continue;
        } 
      }  
      // creo nuovo record        
      newrec.zero();    
      // setto i campi indicati                   
      FOR_EACH_ASSOC_STRING(fieldlist, obj, key, str)
      {                 
        fieldname = key;
        fieldvalue = str;
        if ((fieldname != CAMPODITTA) && (fieldvalue[0]!='!'))
          newrec.put(key, oldfile->get(str));
        else
        {
          if (fieldvalue.mid(0,4) == "!_GR")
          {
            TString80 tmp;
            tmp = oldfile->get(fieldvalue.mid(5));
            newrec.put(key,atoi(tmp.mid(0,3)));
          }
          else if (fieldvalue.mid(0,4) == "!_CO")
          {
            TString80 tmp;
            tmp = oldfile->get(fieldvalue.mid(5));
            newrec.put(key,atoi(tmp.mid(3,3)));
          }
          else if (fieldvalue.sub(0,4) == "!_SO")
          {
            TString80 tmp;
            tmp = oldfile->get(fieldvalue.mid(5));
            newrec.put(key,atol(tmp.mid(6,6)));
          }
        } 
      } 
      // scrivo il record sul nuovo file
      int errore = newrec.write(*newfile);
    }
    delete pi;   
    delete newfile;
    delete oldfile;
  }
  else  
    error_box("Errore in compattamento dati.\nFile %d : %d", nflogicnum,err);
  return 0;
}

int TConversione_cespiti::conv_par(const TFilename& ofname, const char* ofpar, int which_config)
{       
  long oldditta = -1;
  long ditta;
  TExternisamfile* oldfile = new TExternisamfile(ofname, FALSE, FALSE);
  TConfig newconfig(which_config, "ce");
  TConfig config("ce0900.ini", (const char*) ofpar);
  TAssoc_array& fieldlist = config.list_variables();
  TString& campoditta = (TString&) config.get(CAMPODITTA);
  TString fieldname, fieldvalue;
  TRectype oldrec = oldfile->curr();
  TProgind *pi;                                   
  TString80 message;
  message.format("Conversione tabella %s", (const char*) ofname);
  pi = new TProgind(oldfile->eod(),message, FALSE, TRUE, 10);
  pi->setstatus(1);
  for (int err = oldfile->first(); err == NOERR; err = oldfile->next())
  {                 
    pi->addstatus(1);
    if (campoditta.not_empty())
    {
      // mi posiziono sulla ditta indicata
      ditta = oldfile->get_long(campoditta);               
      // i record sono ordinati per ditta!                                        
      if (oldditta != ditta)
      {
        oldditta = ditta;
        if (daconvertire(ditta))
        {
          set_firm(ditta);                                        
          newconfig.set_paragraph("cg");
          newconfig = TConfig(which_config, "ce");
        } 
        else                                                      
        {
          TString256 s;
          s.format("La ditta %ld indicata nel file %s non é stata selezionata per la conversione", ditta, (const char*) ofname);
          write_log(s);
          continue;
        } 
      } 
    } 
    // setto i campi indicati                   
    FOR_EACH_ASSOC_STRING(fieldlist, obj, key, str)
    {                 
      fieldname = key;
      fieldvalue = str;
      if ((fieldname != CAMPODITTA) && (fieldvalue[0]!='!'))
        newconfig.set(key,  oldfile->get(str));
      else
      {
        if (fieldvalue.mid(0,4) == "!_GR")
        {
          TString80 tmp;
          tmp = oldfile->get(fieldvalue.mid(5));
          newconfig.set(key,atoi(tmp.mid(0,3)));
        }
        else if (fieldvalue.mid(0,4) == "!_CO")
        {
          TString80 tmp;
          tmp = oldfile->get(fieldvalue.mid(5));
          newconfig.set(key,atoi(tmp.mid(3,3)));
        }
        else if (fieldvalue.sub(0,4) == "!_SO")
        {
          TString80 tmp;
          tmp = oldfile->get(fieldvalue.mid(5));
          newconfig.set(key,atol(tmp.mid(6,6)));
        }
        else if (fieldvalue.sub(0,4) == "!_ES")
          newconfig.set(key,get_codesc(oldfile->get_date(fieldvalue.mid(5)),FALSE));
        else if (fieldvalue.sub(0,4) == "!_AN")
        {
          TString80 tmp;
          tmp = oldfile->get(fieldvalue.mid(5));
          newconfig.set(key,tmp.mid(6));
        } 
      } 
    } 
    // verificare se occorre registrare (di solito si cambia paragrafo)
  }
  delete pi;
  delete oldfile;
  return 0;
}

int TConversione_cespiti::get_codesc(const TDate& date, const bool fatal)
{
  TEsercizi_contabili esercizi;
  int esc = esercizi.date2esc(date);
  if (esc == 0)
  {
    TString80 s;
    s.format("Non esiste il codice esercizio con data iniziale %s", (const char*) date.string());
    write_log(s);
    if (fatal)
      fatal_box(s);
  }          
  return esc;
}

const char TConversione_cespiti::conv_imptmc(int cod)
{
  switch (cod)
  {
    case 1:
      return 'S';
    break;
    case 2:
      return 'N';
    break;
    case 3:
      return 'O';
    break;
    default:
      return ' ';
  }
  return ' ';   
}

//funzione che ritorna il nome del file dei dati da resettare con la zap_file
HIDDEN const TString& build_name(int logicnum)
{

  TDir d; d.get(logicnum, _nolock, _nordir, _sysdirop);
  
  static TFilename _filename;
  _filename = d.filename();  
  return _filename;
}

//funzione per resettare i files e gli indici
int TConversione_cespiti::zap_file(int lf) const
{ 
  TFilename name = build_name(lf);
  if (name[0] == '%') name.ltrim(1);
  TExternisamfile f(name);
  return f.zap();
}


int ce0900(int argc, char* argv[])
{
  TConversione_cespiti a ;
  a.run(argc, argv, "Conversione cespiti");
  return 0;
}