diff --git a/mg/mglib01.cpp b/mg/mglib01.cpp
index 148009ed5..4b916f1a8 100755
--- a/mg/mglib01.cpp
+++ b/mg/mglib01.cpp
@@ -6,6 +6,7 @@
 #include <defmask.h>
 
 #include "mglib01.h"
+#include "..\cg\cglib.h"
 
 // **************************************
 // **************************************
@@ -25,12 +26,12 @@ TRectype & THead_lines_record::row(int index) const  // riga del corpo
 {
   if (index > _rows->rows() || index < 0)
     CHECKD(FALSE, "Riga non esistente ", index);
-	return _rows->row(index, FALSE);
+  return _rows->row(index, FALSE);
 }
 
 void THead_lines_record::put_str(const char* fieldname, const char* val)
 {          
-	TString v(val);
+  TString v(val);
   // cambio 
   //if (strcmp(fieldname, "TIPODOC") == 0 && TRectype::get("TIPODOC") != v)
   //{
@@ -48,45 +49,45 @@ void THead_lines_record::put_str(const char* fieldname, const char* val)
 //*****
 // metodi public
 THead_lines_record::THead_lines_record(int hfn, int rfn,const char *numfield):
-	TAuto_variable_rectype(hfn),
+  TAuto_variable_rectype(hfn),
   _file(hfn),
   _rfile(rfn),
   _numfield(numfield)
 {
- 	_rows= new TRecord_array(rfn,numfield); // inizializza il record array delle righe
+  _rows= new TRecord_array(rfn,numfield); // inizializza il record array delle righe
 }
 
 THead_lines_record::THead_lines_record(const TBaseisamfile* i,int rfn,const char *numfield):
-	TAuto_variable_rectype(i),
+  TAuto_variable_rectype(i),
   _numfield(numfield)
 {
- 	_rows= new TRecord_array(rfn,numfield); // inizializza il record array delle righe
+  _rows= new TRecord_array(rfn,numfield); // inizializza il record array delle righe
 }
 
 THead_lines_record::THead_lines_record(const TRectype & r,int rfn,const char *numfield):
-	TAuto_variable_rectype(r),
+  TAuto_variable_rectype(r),
   _numfield(numfield)
 {
- 	_rows= new TRecord_array(rfn,numfield); // inizializza il record array delle righe
+  _rows= new TRecord_array(rfn,numfield); // inizializza il record array delle righe
 }
 
 // @doc INTERNAL
 
 // @mfunc costruttore di copia
 THead_lines_record::THead_lines_record(const THead_lines_record& r):
-	TAuto_variable_rectype((TAuto_variable_rectype &)r)
+  TAuto_variable_rectype((TAuto_variable_rectype &)r)
 {
-	// copia..
-	_rows= new TRecord_array(* r._rows); // inizializza il record array delle righe
-	_nuovo=r._nuovo;
-  _file=r._file;		// file principale  
-  _rfile=r._rfile;		// file delle righe
+  // copia..
+  _rows= new TRecord_array(* r._rows); // inizializza il record array delle righe
+  _nuovo=r._nuovo;
+  _file=r._file;    // file principale  
+  _rfile=r._rfile;    // file delle righe
   _numfield=r._numfield; 
 }
 
 THead_lines_record::~THead_lines_record() 
 {
-	delete _rows;
+  delete _rows;
 }
 
 
@@ -113,7 +114,7 @@ TRectype & THead_lines_record::operator =(const char * r)
 
 void THead_lines_record::zero(const char * fieldname)
 {
-	// resetta il record righe solo se .....
+  // resetta il record righe solo se .....
 //  if (strcmp(fieldname, "TIPODOC") == 0)
     reset_fields(*this);
   TAuto_variable_rectype::zero(fieldname);
@@ -133,13 +134,13 @@ void THead_lines_record::set_fields(TAuto_variable_rectype & rec)
 }
 
 
-int THead_lines_record::read(TBaseisamfile& f, word op, word lockop, TDate& atdate)
+int THead_lines_record::read(TBaseisamfile& f, word op, word lockop)
 {
   TRectype line_key(_rfile);
 
   copy_linekey(head(),line_key);
   
-  int err = TRectype::read(f,op,lockop,atdate);
+  int err = TRectype::read(f,op,lockop);
   if (err == NOERR)
   {
     _nuovo = FALSE;
@@ -147,7 +148,7 @@ int THead_lines_record::read(TBaseisamfile& f, word op, word lockop, TDate& atda
   }  
   else
   {
-		// nuovo oggetto: resetta tutto
+    // nuovo oggetto: resetta tutto
     _nuovo = TRUE;
     destroy_rows();
     _rows->set_key((TRectype *)(line_key.dup()));  // ok
@@ -171,7 +172,7 @@ int THead_lines_record::read(TBaseisamfile& f, word op, word lockop, TDate& atda
   }  
   else
   {
-		// nuovo oggetto: resetta tutto
+    // nuovo oggetto: resetta tutto
     _nuovo = TRUE;
     head() = rec;
     destroy_rows();
@@ -180,13 +181,13 @@ int THead_lines_record::read(TBaseisamfile& f, word op, word lockop, TDate& atda
   return err;
 } 
 */
-int THead_lines_record::write(TBaseisamfile& f, TDate& atdate ) const 
+int THead_lines_record::write(TBaseisamfile& f) const 
 {
-	return write_rewrite(f,FALSE);
+  return write_rewrite(f,FALSE);
 }
-int THead_lines_record::rewrite(TBaseisamfile& f, TDate& atdate) const 
+int THead_lines_record::rewrite(TBaseisamfile& f) const 
 {
-	return write_rewrite(f,TRUE);
+  return write_rewrite(f,TRUE);
 }
 
 
@@ -237,11 +238,11 @@ int THead_lines_record::write_rewrite(TBaseisamfile& f,bool re ) const
 }
 
 
-int THead_lines_record::remove(TBaseisamfile& f, TDate& atdate ) const 
+int THead_lines_record::remove(TBaseisamfile& f) const 
 {
   int err = _rows->remove();
   if (err == NOERR)
-    err = TRectype::remove(f,atdate);
+    err = TRectype::remove(f);
   return err;  
 }
 
@@ -250,31 +251,31 @@ int THead_lines_record::remove(TBaseisamfile& f, TDate& atdate ) const
 
 // @mfunc costruttore di copia
 TTimed_box::TTimed_box(const char * header,const char * message,int seconds,short button_id,int x,int y)
-	: TMask(header,1,x,y)
+  : TMask(header,1,x,y)
 {
-	// costruisce una maschera run time
-	add_memo(FIRST_FIELD, 0, "", 1, 0,-1,-3);
-	set(FIRST_FIELD, message);
+  // costruisce una maschera run time
+  add_memo(FIRST_FIELD, 0, "", 1, 0,-1,-3);
+  set(FIRST_FIELD, message);
 
-	// setta il timer per l'evento
-	_timer_delay=seconds	*1000+1;
-	_timer_id=XVT_TIMER_ERROR;
-	_button_id=button_id;
+  // setta il timer per l'evento
+  _timer_delay=seconds  *1000+1;
+  _timer_id=XVT_TIMER_ERROR;
+  _button_id=button_id;
 }
 
 void TTimed_box::start_run()
 {
-	if (_timer_id!=XVT_TIMER_ERROR)
-		xvt_timer_destroy(_timer_id);
-	_timer_id=xvt_timer_create(win(),_timer_delay);
-	TMask::start_run();
+  if (_timer_id!=XVT_TIMER_ERROR)
+    xvt_timer_destroy(_timer_id);
+  _timer_id=xvt_timer_create(win(),_timer_delay);
+  TMask::start_run();
 }
 
 void TTimed_box::handler(WINDOW win, EVENT* ep)
 {   
   if (ep->type == E_TIMER && ep->v.timer.id==_timer_id)
   {
-  	send_key(K_SPACE,DLG_OK);
+    send_key(K_SPACE,DLG_OK);
   }
   TMask::handler(win, ep);
 }
@@ -282,14 +283,14 @@ void TTimed_box::handler(WINDOW win, EVENT* ep)
 class TTimed_breakbox: public TTimed_box
 {
 public:
-	TTimed_breakbox(const char * message,int seconds,int x=40,int y=10);
+  TTimed_breakbox(const char * message,int seconds,int x=40,int y=10);
 };
 
 TTimed_breakbox::TTimed_breakbox(const char * message,int seconds,int x,int y)
-	: TTimed_box("Richiesta di interruzione",message,seconds,DLG_OK,x,y)
+  : TTimed_box("Richiesta di interruzione",message,seconds,DLG_OK,x,y)
 {
   add_button(DLG_CANCEL, 0, "Interrompi", -22, -1, 12, 2,"",0);
-	add_button(DLG_OK,     0, "Riprova", -12, -1, 12, 2,"",0);
+  add_button(DLG_OK,     0, "Riprova", -12, -1, 12, 2,"",0);
 }
 
 
@@ -311,81 +312,81 @@ TTimed_breakbox::TTimed_breakbox(const char * message,int seconds,int x,int y)
 // **************************
 // classe livelli giacenze
 TMag_livelli:: TMag_livelli(const char *tabname)
-{	
-	TTable _tabformato(tabname);	
-	int e;
-	
-	_last_level=0;
-	e=_tabformato.first();
-	for (int i=0; i<	MANY_MAG_LEV; i++) {
-		_enabled[i]=(e==NOERR);
-		if (_enabled[i]) {
-			_name[i]=_tabformato.get("S0");
-			_code_lenght[i]=atoi(_tabformato.get("I0"));
-			_picture[i]=_tabformato.get("S1");
-			_last_level=i+1;
-		} else {
-			_name[i]="";
-			_code_lenght[i]=0;
-			_picture[i]="";
-		}
-		e=_tabformato.next();
-	}
+{ 
+  TTable _tabformato(tabname);  
+  int e;
+  
+  _last_level=0;
+  e=_tabformato.first();
+  for (int i=0; i<  MANY_MAG_LEV; i++) {
+    _enabled[i]=(e==NOERR);
+    if (_enabled[i]) {
+      _name[i]=_tabformato.get("S0");
+      _code_lenght[i]=atoi(_tabformato.get("I0"));
+      _picture[i]=_tabformato.get("S1");
+      _last_level=i+1;
+    } else {
+      _name[i]="";
+      _code_lenght[i]=0;
+      _picture[i]="";
+    }
+    e=_tabformato.next();
+  }
 }
 
 const bool TMag_livelli::enabled(int levnum)
 {
-	if (levnum<=MANY_MAG_LEV &&  levnum>0)
-		return(_enabled[levnum-1]);
-	else
-		return(FALSE)	;
+  if (levnum<=MANY_MAG_LEV &&  levnum>0)
+    return(_enabled[levnum-1]);
+  else
+    return(FALSE) ;
 }
 
 const int TMag_livelli::code_lenght(int levnum)
 {
-	if (levnum<=MANY_MAG_LEV &&  levnum>0)
-		return(_code_lenght[levnum-1]);
-	else
-		return(0)	;
+  if (levnum<=MANY_MAG_LEV &&  levnum>0)
+    return(_code_lenght[levnum-1]);
+  else
+    return(0) ;
 }
 
 const TString & TMag_livelli::name(int levnum)
 {
-	if (levnum<=MANY_MAG_LEV &&  levnum>0)
-		return(_name[levnum-1]);
-	else
-		return("");	
+  if (levnum<=MANY_MAG_LEV &&  levnum>0)
+    return(_name[levnum-1]);
+  else
+    return(""); 
 }
 
 const TString & TMag_livelli::picture(int levnum)
 {
-	if (levnum<=MANY_MAG_LEV &&  levnum>0)
-		return(_picture[levnum-1]);
-	else
-		return("");	
+  if (levnum<=MANY_MAG_LEV &&  levnum>0)
+    return(_picture[levnum-1]);
+  else
+    return(""); 
 }
 
 void TMag_livelli::pack_grpcode(TString & pc, const TString &codlev, const int levnum)
 {
       
   int start=0;
-	for (int i=1; i<levnum; i++) 
-		start+=	_code_lenght[i-1];
-	pc.overwrite(codlev.left(_code_lenght[levnum-1]),start);	    	
+  for (int i=1; i<levnum; i++) 
+    start+= _code_lenght[i-1];
+  pc.overwrite(codlev.left(_code_lenght[levnum-1]),start);        
 }
 
 TString TMag_livelli::unpack_grpcode(const TString & pc, const int levnum)
 {
-	int start=0;
-	for (int i=1; i<levnum; i++) 
-		start+=	_code_lenght[i-1];
-	if (start>=pc.len())
-		return("");
-	else	 {
-		if (levnum != _last_level && !_enabled[levnum-1])
-			return("");
-		return(pc.mid(start,levnum == _last_level ? -1 : _code_lenght[levnum-1]));
-	}
+  int start=0;
+  for (int i=1; i<levnum; i++) 
+    start+= _code_lenght[i-1];
+  if (start>=pc.len())
+    return("");
+  else   {
+    if (levnum != _last_level && !_enabled[levnum-1])
+      return("");
+    return(pc.mid(start,levnum == _last_level ? -1 : _code_lenght[levnum-1]));
+  }
 }
 
 
@@ -395,60 +396,60 @@ TString TMag_livelli::unpack_grpcode(const TString & pc, const int levnum)
 // *******************************
 TStateset::TStateset()
 { 
-	empty();
+  empty();
 }
 
 TStateset & TStateset::empty()
 { _current=0;
-	for (int i= 0; i< MAXSTATES; _container[i++]=0);
-	return *this;
+  for (int i= 0; i< MAXSTATES; _container[i++]=0);
+  return *this;
 }
 
 TStateset & TStateset::enclose(int el)
 { if (el< MAXSTATES && el>=0)
-		_container[el]=1;
-	return *this;
+    _container[el]=1;
+  return *this;
 }
 
 TStateset & TStateset::singleton(int el)
 { empty();
-	_container[el]=1;
-	return *this;
+  _container[el]=1;
+  return *this;
 }
 
 TStateset & TStateset::cap(TStateset & s)
 {
-	for (int i= 0; i< MAXSTATES; i++)
-		_container[i]|=s._container[i];
-	return *this;
+  for (int i= 0; i< MAXSTATES; i++)
+    _container[i]|=s._container[i];
+  return *this;
 }
-	
+  
 bool TStateset::is_empty() const
 { 
-	for (int i= 0; i< MAXSTATES; i++) {
-		if (_container[i]) return FALSE;
-	}
-	return TRUE;
+  for (int i= 0; i< MAXSTATES; i++) {
+    if (_container[i]) return FALSE;
+  }
+  return TRUE;
 }
 
 bool TStateset::is_member(int e)    const
 { 
-	return ((e< MAXSTATES && e>=0)?  _container[e] : FALSE );
+  return ((e< MAXSTATES && e>=0)?  _container[e] : FALSE );
 }
 
 int TStateset::get_first()
 {
-	_current=-1;
-	return(get_next());
+  _current=-1;
+  return(get_next());
 }
 
 int TStateset::get_next()
 {
-	while (_current+1 < MAXSTATES)  {
-		if (_container[++_current])
-			return _current;
-	} 
-	return (-1);	
+  while (_current+1 < MAXSTATES)  {
+    if (_container[++_current])
+      return _current;
+  } 
+  return (-1);  
 }
 
 // *******************************
@@ -461,104 +462,104 @@ int TStateset::get_next()
 // labels and states
 bool TR_automa::is_state(int statenum)
 {
-	return(statenum<=_maxstate && statenum>0);
+  return(statenum<=_maxstate && statenum>0);
 }
 
 // restituisce il numero dello stato con quella etichetta
 int TR_automa::label2state(const char *label)
 {
-	for (int s=0; s<_maxstate;s++) {
-		if (*(st[s]._label)==label)
-			return(s+1);
-	}
-	return(0);	
+  for (int s=0; s<_maxstate;s++) {
+    if (*(st[s]._label)==label)
+      return(s+1);
+  }
+  return(0);  
 }
 
 
 // resetta uno stato dell'automa (senza eliminarlo)
 TR_automa & TR_automa::reset_state(int statenum)
 {
-	int _from,_to;
-	if (statenum>0 && statenum<=_maxstate) {
-		_from=statenum;
-		_to=statenum;
-	} else {
-		_maxstate=0;
-		_isdeterministic=TRUE;
-		_from=1;
-		_to=MAXSTATES;
-	}	
-	{
-		for (int i=_from; i<=_to;i++) {
-			set_label(i,"");
-			set_final(i,FALSE);
-			for (int j=0; j<MAXSIMBOLS;j++) {
-				del_trans(i,j);	
-			}
-		}			
-	}
-	return *this;
+  int _from,_to;
+  if (statenum>0 && statenum<=_maxstate) {
+    _from=statenum;
+    _to=statenum;
+  } else {
+    _maxstate=0;
+    _isdeterministic=TRUE;
+    _from=1;
+    _to=MAXSTATES;
+  } 
+  {
+    for (int i=_from; i<=_to;i++) {
+      set_label(i,"");
+      set_final(i,FALSE);
+      for (int j=0; j<MAXSIMBOLS;j++) {
+        del_trans(i,j); 
+      }
+    }     
+  }
+  return *this;
 }
 
 // aggiunge una label
 int TR_automa::add_state(const char * label)
 {
-	_maxstate++;
-	reset_state(_maxstate);
-	set_label(_maxstate,label);
-	return _maxstate;
+  _maxstate++;
+  reset_state(_maxstate);
+  set_label(_maxstate,label);
+  return _maxstate;
 }
 
 TR_automa & TR_automa::set_label(int statenum, const char * name)
 {
-	(*(st[statenum-1]._label))=name;
-	return *this;
+  (*(st[statenum-1]._label))=name;
+  return *this;
 }
 
 const char * TR_automa::label(int statenum)
 {
-	return (*(st[statenum-1]._label));
+  return (*(st[statenum-1]._label));
 }
 
 bool TR_automa::is_final(int statenum) const
-{	
-	return (st[statenum-1]._final);
+{ 
+  return (st[statenum-1]._final);
 }
 
 bool TR_automa::is_final(TStateset ss ) const
-{	
-	bool retv=FALSE;
-	int statenum=ss.get_first();
-	do {
-		retv=retv || is_final(statenum);
-	} while ((statenum=ss.get_next())>0);
-		
-	return retv;
+{ 
+  bool retv=FALSE;
+  int statenum=ss.get_first();
+  do {
+    retv=retv || is_final(statenum);
+  } while ((statenum=ss.get_next())>0);
+    
+  return retv;
 }
 
 TR_automa & TR_automa::set_final(int statenum,bool v)
 {
-	st[statenum-1]._final=v;
-	return *this;
+  st[statenum-1]._final=v;
+  return *this;
 }
 
 //*******************
 // bows
 void TR_automa::add_tran(int statenum, unsigned char symbol,int next)
 {
-	st[statenum-1]._transaction[symbol]=next;		
-	if (symbol==EPSILON)
-		_isdeterministic=FALSE;
+  st[statenum-1]._transaction[symbol]=next;   
+  if (symbol==EPSILON)
+    _isdeterministic=FALSE;
 }
 
 void TR_automa::del_trans(int statenum, unsigned char symbol)
 {
-	st[statenum-1]._transaction[symbol]=0;
+  st[statenum-1]._transaction[symbol]=0;
 }
 
 int TR_automa::trans_to(int statenum, unsigned char symbol)
 {
-	return (st[statenum-1]._transaction[symbol]);		
+  return (st[statenum-1]._transaction[symbol]);   
 }
 
 // costruttore che crea un automa non deterministico 
@@ -566,136 +567,136 @@ int TR_automa::trans_to(int statenum, unsigned char symbol)
 // eventualmente duplica un automa (e lo rende deterministico)
 TR_automa::TR_automa(TR_automa * aa,bool makedet) 
 {
-	TStateset arrival;
-	TStateset newstateset;
-	TString16  tmplabel;
-	int curr_new_state;
+  TStateset arrival;
+  TStateset newstateset;
+  TString16  tmplabel;
+  int curr_new_state;
 
-	for (int i=0; i<MAXSTATES;i++) {
-		st[i]._label = new TString16;
-	}			
-	if (aa==NULL) {
-	  reset_state();
-		return;
-	}
-	if (makedet) {
-	  reset_state();
-		// crea il primo stato nell'automa deterministico
-		set2label(aa->union_of_closures(newstateset.singleton(FIRST_STATE)),tmplabel);
-		add_state(tmplabel);
-		curr_new_state=FIRST_STATE;
-		while (is_state(curr_new_state)) {
-			// determina l'insieme degli stati dell'automa non deterministico
-			// che corrispondono a questo stato dell'automa deterministico
-			label2set(label(curr_new_state),newstateset);
-			// lo stato è finale se include stati finali dell'automa non det.
-			set_final(curr_new_state,aa->is_final(newstateset));
-			// determina tutte le transazioni 
-			for (short symbol=FIRST_NEMPTY_SYMBOL; symbol<MAXSIMBOLS; symbol++) {
-				// determina lo stato di arrivo nell'automa det.:
+  for (int i=0; i<MAXSTATES;i++) {
+    st[i]._label = new TString16;
+  }     
+  if (aa==NULL) {
+    reset_state();
+    return;
+  }
+  if (makedet) {
+    reset_state();
+    // crea il primo stato nell'automa deterministico
+    set2label(aa->union_of_closures(newstateset.singleton(FIRST_STATE)),tmplabel);
+    add_state(tmplabel);
+    curr_new_state=FIRST_STATE;
+    while (is_state(curr_new_state)) {
+      // determina l'insieme degli stati dell'automa non deterministico
+      // che corrispondono a questo stato dell'automa deterministico
+      label2set(label(curr_new_state),newstateset);
+      // lo stato è finale se include stati finali dell'automa non det.
+      set_final(curr_new_state,aa->is_final(newstateset));
+      // determina tutte le transazioni 
+      for (short symbol=FIRST_NEMPTY_SYMBOL; symbol<MAXSIMBOLS; symbol++) {
+        // determina lo stato di arrivo nell'automa det.:
         // esso è pari all'insieme degli stati raggiunti col questo simbolo 
         // dal sottoinsieme degli stati dell'automa non det. che etichetta il nuovo stato nell'automa det.
         arrival.empty();
-       	int new_next,old_next;
+        int new_next,old_next;
         int old_state=newstateset.get_first() ;
         do {
-        	if (old_next=aa->trans_to(old_state,symbol))
-        		arrival.enclose(old_next);
+          if (old_next=aa->trans_to(old_state,symbol))
+            arrival.enclose(old_next);
         } while ((old_state=newstateset.get_next())>0);
         if (!arrival.is_empty()) {
-        		// crea il nuovo arco nell'automa deterministico
-        	set2label(aa->union_of_closures(arrival),tmplabel);
-    			if (!(new_next=label2state(tmplabel))) {
-					new_next=add_state(tmplabel);
-					}	
-					add_tran(curr_new_state,symbol,new_next);
-				}
-			}
-			curr_new_state++;
-		}
-	  _isdeterministic=TRUE;
-	} // fine  conversione
-	else 
-	{
-		*this=*aa;
-		for (int i=0; i<MAXSTATES;i++) {
-			st[i]._label= aa->st[i]._label;
-		}			
-	}
+            // crea il nuovo arco nell'automa deterministico
+          set2label(aa->union_of_closures(arrival),tmplabel);
+          if (!(new_next=label2state(tmplabel))) {
+          new_next=add_state(tmplabel);
+          } 
+          add_tran(curr_new_state,symbol,new_next);
+        }
+      }
+      curr_new_state++;
+    }
+    _isdeterministic=TRUE;
+  } // fine  conversione
+  else 
+  {
+    *this=*aa;
+    for (int i=0; i<MAXSTATES;i++) {
+      st[i]._label= aa->st[i]._label;
+    }     
+  }
 }
 
 
 TR_automa::~TR_automa()
 { 
-	for (int i=0; i<MAXSTATES;i++) {
-		delete (st[i]._label);
-	}			
+  for (int i=0; i<MAXSTATES;i++) {
+    delete (st[i]._label);
+  }     
 }
 
 
 void TR_automa::set2label(const TStateset ss,TString16 & label)
 {
-	char coded[MAXSTATES];
-	char c=0;
-	for (int i= 0; i< MAXSTATES; i++) {
-		if (ss.is_member(i)) 
-			coded[c++]=(char)(i+'0');
-	}
-	coded[c]='\0';
-	label=coded;		
+  char coded[MAXSTATES];
+  char c=0;
+  for (int i= 0; i< MAXSTATES; i++) {
+    if (ss.is_member(i)) 
+      coded[c++]=(char)(i+'0');
+  }
+  coded[c]='\0';
+  label=coded;    
 }
 
 void TR_automa::label2set(const TString16 & label,TStateset & ss)
 {
-	ss.empty();
-	for (int i= 0; i<= label.len();i++)
-		ss.enclose(int(label[i]-'0'));
+  ss.empty();
+  for (int i= 0; i<= label.len();i++)
+    ss.enclose(int(label[i]-'0'));
 }
 
 
 // costruisce l'unione delle epslilon closures
 TStateset TR_automa::union_of_closures(TStateset &start_set)
 {
-	TStateset u_of_clo,clo;
-	int _state,_next;
-	bool toadd;
-	
-	
-	u_of_clo.empty();
-	_state=start_set.get_first() ;
+  TStateset u_of_clo,clo;
+  int _state,_next;
+  bool toadd;
+  
+  
+  u_of_clo.empty();
+  _state=start_set.get_first() ;
   do {
-		// la chiusura è composta dallo stato e tutte le sue transazioni epsilon
-		clo.singleton(_state);
-		do {
-			int _state2=clo.get_first();
-			do {
-				toadd=((_next=trans_to(_state2,EPSILON)) && (!clo.is_member(_next)));
-				if (toadd)
-					clo.enclose(_next);
-			} while	((_state2=clo.get_next())>0);
-		} while (toadd) ;
-		u_of_clo.cap(clo);
-	} while ((_state=start_set.get_next())>0);
-	return u_of_clo;
+    // la chiusura è composta dallo stato e tutte le sue transazioni epsilon
+    clo.singleton(_state);
+    do {
+      int _state2=clo.get_first();
+      do {
+        toadd=((_next=trans_to(_state2,EPSILON)) && (!clo.is_member(_next)));
+        if (toadd)
+          clo.enclose(_next);
+      } while ((_state2=clo.get_next())>0);
+    } while (toadd) ;
+    u_of_clo.cap(clo);
+  } while ((_state=start_set.get_next())>0);
+  return u_of_clo;
 }
 
 // tenta di riconoscere la stringa passata
 bool TR_automa::recognized(const char * t_str) 
 {
-	if (_isdeterministic) {
-		// ricoNosce la stringa di token
-		int curr_state=FIRST_STATE;
-		for (int i=0; t_str[i]; i++) {
-			if (!(curr_state=trans_to(curr_state,t_str[i])))
-				// fine per mancanza di trasizioni
-				return FALSE; 
-		}
-		// fine per mancanza di caratteri di input della stringa
-		return (is_final(curr_state));
-	} else {
-		//    
-		return FALSE;
-	}
+  if (_isdeterministic) {
+    // ricoNosce la stringa di token
+    int curr_state=FIRST_STATE;
+    for (int i=0; t_str[i]; i++) {
+      if (!(curr_state=trans_to(curr_state,t_str[i])))
+        // fine per mancanza di trasizioni
+        return FALSE; 
+    }
+    // fine per mancanza di caratteri di input della stringa
+    return (is_final(curr_state));
+  } else {
+    //    
+    return FALSE;
+  }
 }
 
 
@@ -710,180 +711,180 @@ bool TR_automa::recognized(const char * t_str)
 
 bool TMetachar::recognized(const char * s)
 {
-	return(_au->recognized(s));
+  return(_au->recognized(s));
 }
         
 void TMetachar::add_tran(int s,unsigned char metasymbol, int nextstate)
 {
-		unsigned char c;
-		switch (metasymbol) {
-			case EPSILON:// blank
-				_au->add_tran(s,EPSILON,nextstate);
-			break;
-			case S_BLANK:// blank
-				_au->add_tran(s,' ',nextstate);
-			break;
-			case S_DIGIT:// cifra 
-				for (c='0';c<='9';c++)
-					_au->add_tran(s,c,nextstate);
-			break;
-			case S_LETTER: // lettera 
-				for (c='a';c<='z';c++)
-					_au->add_tran(s,c,nextstate);
-				for (c='A';c<='Z';c++)
-					_au->add_tran(s,c,nextstate);
-			break;
-			case S_ANY: // qualsiasi carattere 
-				for (c=MAXSIMBOLS-1;c>=FIRST_NEMPTY_SYMBOL;c--)
-					_au->add_tran(s,c,nextstate);
-			break;
-			default:
-					_au->add_tran(s,metasymbol,nextstate);
-			break;
-		}
+    unsigned char c;
+    switch (metasymbol) {
+      case EPSILON:// blank
+        _au->add_tran(s,EPSILON,nextstate);
+      break;
+      case S_BLANK:// blank
+        _au->add_tran(s,' ',nextstate);
+      break;
+      case S_DIGIT:// cifra 
+        for (c='0';c<='9';c++)
+          _au->add_tran(s,c,nextstate);
+      break;
+      case S_LETTER: // lettera 
+        for (c='a';c<='z';c++)
+          _au->add_tran(s,c,nextstate);
+        for (c='A';c<='Z';c++)
+          _au->add_tran(s,c,nextstate);
+      break;
+      case S_ANY: // qualsiasi carattere 
+        for (c=MAXSIMBOLS-1;c>=FIRST_NEMPTY_SYMBOL;c--)
+          _au->add_tran(s,c,nextstate);
+      break;
+      default:
+          _au->add_tran(s,metasymbol,nextstate);
+      break;
+    }
 }
 
 // restituisce la stringa di metacaratteri del linguaggio riconosciuto
 const char * TMetachar::language() const
 {
-	return(_language);
+  return(_language);
 }
 
 void TMetachar::set_language(const char * language)
 {
-	int s;
-	bool escaped_char=FALSE;
+  int s;
+  bool escaped_char=FALSE;
   TString16 label("-"),nextlabel("-");
   
-	// crea gli insiemi di metacaratteri standard
-	strcpy(_metach_mand,"0LA&");
-	strcpy(_metach_opz,"#9?ac");
+  // crea gli insiemi di metacaratteri standard
+  strcpy(_metach_mand,"0LA&");
+  strcpy(_metach_opz,"#9?ac");
 
-	
-	_language=language;
-	// crea l'automa 
-	_au->reset_state();
-	for (int i=0; language[i]; i++) {
-		label[0]='a'+i;
-		nextlabel[0]='a'+i+1;
-		if (language[i]!=C_ESCAPEMETA) {
-			if (!escaped_char)
-			{
-			// meta-caratteri e literal fuori set
-				s=_au->add_state(label);
-				switch (language[i]) {
-					case '#':// cifra o blank opzionale
-						add_tran(s,S_BLANK,s+1);
-						add_tran(s,'-',s+1);
-						add_tran(s,'+',s+1);
-					case '9':// cifra opzionale
-						add_tran(s,EPSILON,s+1);
-					case '0':// cifra obbligatoria
-						add_tran(s,S_DIGIT,s+1);
-					break;
-					case '?': // lettera opzionale
-						add_tran(s,EPSILON,s+1);
-					case 'L': // lettera obbligatoria
-						add_tran(s,S_LETTER,s+1);
-					break;
-					case 'a': // lettera o numero opzionale
-						add_tran(s,EPSILON,s+1);
-					case 'A': // lettera o numero obbligatorio
-						add_tran(s,S_LETTER,s+1);
-						add_tran(s,S_DIGIT,s+1);
-					break;
-					case 'c': // qualsiasi carattere opzionale
-						add_tran(s,EPSILON,s+1);
-					case '&': // qualsiasi carattere obbligatorio
-						add_tran(s,S_ANY,s+1);
-					break;
-					default:
-						_au->add_tran(s,language[i],s+1);
-					break;
-				}
-			} else {
-			// escaped char
-					s=_au->add_state(label);
-				_au->add_tran(s,language[i],s+1);
-			}
-		}
-		escaped_char=(language[i]==C_ESCAPEMETA);
-	} // end of loop
-	// aggiunge lo stato finale
-	s=_au->add_state(nextlabel);
-	_au->set_final(s);
+  
+  _language=language;
+  // crea l'automa 
+  _au->reset_state();
+  for (int i=0; language[i]; i++) {
+    label[0]='a'+i;
+    nextlabel[0]='a'+i+1;
+    if (language[i]!=C_ESCAPEMETA) {
+      if (!escaped_char)
+      {
+      // meta-caratteri e literal fuori set
+        s=_au->add_state(label);
+        switch (language[i]) {
+          case '#':// cifra o blank opzionale
+            add_tran(s,S_BLANK,s+1);
+            add_tran(s,'-',s+1);
+            add_tran(s,'+',s+1);
+          case '9':// cifra opzionale
+            add_tran(s,EPSILON,s+1);
+          case '0':// cifra obbligatoria
+            add_tran(s,S_DIGIT,s+1);
+          break;
+          case '?': // lettera opzionale
+            add_tran(s,EPSILON,s+1);
+          case 'L': // lettera obbligatoria
+            add_tran(s,S_LETTER,s+1);
+          break;
+          case 'a': // lettera o numero opzionale
+            add_tran(s,EPSILON,s+1);
+          case 'A': // lettera o numero obbligatorio
+            add_tran(s,S_LETTER,s+1);
+            add_tran(s,S_DIGIT,s+1);
+          break;
+          case 'c': // qualsiasi carattere opzionale
+            add_tran(s,EPSILON,s+1);
+          case '&': // qualsiasi carattere obbligatorio
+            add_tran(s,S_ANY,s+1);
+          break;
+          default:
+            _au->add_tran(s,language[i],s+1);
+          break;
+        }
+      } else {
+      // escaped char
+          s=_au->add_state(label);
+        _au->add_tran(s,language[i],s+1);
+      }
+    }
+    escaped_char=(language[i]==C_ESCAPEMETA);
+  } // end of loop
+  // aggiunge lo stato finale
+  s=_au->add_state(nextlabel);
+  _au->set_final(s);
 
 }
 
 // ricerca caratteri del set opzionale
 bool TMetachar::has_opzchars(const char * pattern)
 {
-	int i=0; 
-	bool next_literal=FALSE;
-	
-	while (pattern[i]) {           
-		if (!next_literal && strchr(_metach_opz,pattern[i]))
-			return(TRUE);
-		next_literal=(!next_literal && pattern[i]==C_ESCAPEMETA);
-		i++;
-	}
-	return(FALSE);
+  int i=0; 
+  bool next_literal=FALSE;
+  
+  while (pattern[i]) {           
+    if (!next_literal && strchr(_metach_opz,pattern[i]))
+      return(TRUE);
+    next_literal=(!next_literal && pattern[i]==C_ESCAPEMETA);
+    i++;
+  }
+  return(FALSE);
 }
 
 // ricerca caratteri del set opzionale
 bool TMetachar::has_mandchars(const char * pattern)
 {
-	int i=0; 
-	bool next_literal=FALSE;
-	
-	while (pattern[i]) {
-		if (next_literal || strchr(_metach_mand,pattern[i]))
-			return(TRUE);
-		next_literal=(!next_literal && pattern[i]==C_ESCAPEMETA);
-		i++;
-	}
-	return(FALSE);
+  int i=0; 
+  bool next_literal=FALSE;
+  
+  while (pattern[i]) {
+    if (next_literal || strchr(_metach_mand,pattern[i]))
+      return(TRUE);
+    next_literal=(!next_literal && pattern[i]==C_ESCAPEMETA);
+    i++;
+  }
+  return(FALSE);
 }
 
 // stabilisce la lunghezza della stringa di metacaratteri
 int TMetachar::maxstrlen(const char * pattern) const
 {
-	int i=0,l=0; 
-	bool next_literal=FALSE;
-	
-	while (pattern[i]) {
-		if (!next_literal)
-			l++;
-		next_literal=(!next_literal && pattern[i]==C_ESCAPEMETA);
-		i++;
-	}
-	return(l);
+  int i=0,l=0; 
+  bool next_literal=FALSE;
+  
+  while (pattern[i]) {
+    if (!next_literal)
+      l++;
+    next_literal=(!next_literal && pattern[i]==C_ESCAPEMETA);
+    i++;
+  }
+  return(l);
 }
 
 // costruttore e distruttore
 TMetachar::TMetachar ()
 {
-	_au = new TR_automa;       
-	set_language("");
+  _au = new TR_automa;       
+  set_language("");
 }
 
 TMetachar::TMetachar (const char * metastr)
 {
-	// crea l'automa e lo trasforma in deterministico
-//	TR_automa auxau;
-//	set_language(&auxau,metastr);
-	_au=new TR_automa;
-	set_language(metastr);
-	if (!_au->is_deterministic()) {
-		TR_automa * auxau = new TR_automa(_au,TRUE);       
-		delete _au;
-		_au=auxau;
-	}	
+  // crea l'automa e lo trasforma in deterministico
+//  TR_automa auxau;
+//  set_language(&auxau,metastr);
+  _au=new TR_automa;
+  set_language(metastr);
+  if (!_au->is_deterministic()) {
+    TR_automa * auxau = new TR_automa(_au,TRUE);       
+    delete _au;
+    _au=auxau;
+  } 
 }
 
 TMetachar::~TMetachar ()
 {
-	delete _au;
+  delete _au;
 }
 
 
@@ -894,18 +895,18 @@ TMetachar::~TMetachar ()
 // ***
 long giac_last_item(const char * annoes, const char *codart) 
 {
-	long r=0;
-	TLocalisamfile mag(LF_MAG);
-	mag.put("ANNOES",annoes);
-	mag.put("CODART",codart);
-	mag.put("NRIGA",1);
-	if (mag.read()==NOERR) 
-	{
-		do 	{
-			r=mag.get_long("NRIGA");
-		} while (mag.next()==NOERR && mag.get("CODART")==codart);
-	}
-	return r;
+  long r=0;
+  TLocalisamfile mag(LF_MAG);
+  mag.put("ANNOES",annoes);
+  mag.put("CODART",codart);
+  mag.put("NRIGA",1);
+  if (mag.read()==NOERR) 
+  {
+    do  {
+      r=mag.get_long("NRIGA");
+    } while (mag.next()==NOERR && mag.get("CODART")==codart);
+  }
+  return r;
 }
 
 // *********************
@@ -915,75 +916,75 @@ long giac_last_item(const char * annoes, const char *codart)
 
 int TCausale_magazzino::sgn(TTipo_saldomag tiposaldo) 
 {
-	switch (tiposaldo) {
-	case s_giac:
-		return get_int("I0");
-	case s_acq:
-		return get_int("I1");
-	case s_ent:
-		return get_int("I2");
-	case s_ven:
-		return get_int("I3");
-	case s_usc:
-		return get_int("I4");
-	case s_ordc:
-		return get_int("I5");
-	case s_ordf:
-		return get_int("I6");
-	case s_incl:
-		return get_int("I7");
-	case s_acl:
-		return get_int("I8");
-	case s_prodc:
-		return get_int("I9");
-	case s_prodf:
-		return get_int("I10");
-	case s_rim:
-		return get_int("I11");
-	case s_scart:
-		return get_int("I12");
-	case s_label:
-		return get_int("I13");
-	default:
-	return 0;
-	}
+  switch (tiposaldo) {
+  case s_giac:
+    return get_int("I0");
+  case s_acq:
+    return get_int("I1");
+  case s_ent:
+    return get_int("I2");
+  case s_ven:
+    return get_int("I3");
+  case s_usc:
+    return get_int("I4");
+  case s_ordc:
+    return get_int("I5");
+  case s_ordf:
+    return get_int("I6");
+  case s_incl:
+    return get_int("I7");
+  case s_acl:
+    return get_int("I8");
+  case s_prodc:
+    return get_int("I9");
+  case s_prodf:
+    return get_int("I10");
+  case s_rim:
+    return get_int("I11");
+  case s_scart:
+    return get_int("I12");
+  case s_label:
+    return get_int("I13");
+  default:
+  return 0;
+  }
 }
 
 
 TCausale_magazzino::TCausale_magazzino(const char * codice):
-	TRectype(LF_TAB)
+  TRectype(LF_TAB)
 {
-	TTable f("CAU");
-	f.put("CODTAB",codice);
-	if (f.read() != NOERR)
-		zero();		
-	else
-		*this=(TCausale_magazzino &)f.curr();
+  TTable f("CAU");
+  f.put("CODTAB",codice);
+  if (f.read() != NOERR)
+    zero();   
+  else
+    *this=(TCausale_magazzino &)f.curr();
 }
 
 // movimenti
 TLine_movmag ::TLine_movmag(const TLine_movmag &l)
 {
-	um=l.um;
-	quant=l.quant;
-	prezzo=l.prezzo;
+  um=l.um;
+  quant=l.quant;
+  prezzo=l.prezzo;
 }
 
 int TLine_movmag::operator==(TLine_movmag &l)
 {
-	return (um==l.um)&&(quant==l.quant)&&(prezzo==l.prezzo);
+  return (um==l.um)&&(quant==l.quant)&&(prezzo==l.prezzo);
 }
 
 
 
 TMov_mag::TMov_mag() : 
-	THead_lines_record(LF_MOVMAG,LF_RMOVMAG,"NRIG"),
-	lines_to_add(),	lines_to_subtract()
-{ 	
+  THead_lines_record(LF_MOVMAG,LF_RMOVMAG,"NRIG"),
+  lines_to_add(), lines_to_subtract()
+{   
 }
 
 TMov_mag::~TMov_mag() 
-{ 	
+{   
 }
 //void TMov_mag::dirty_fields()
 //{
@@ -995,7 +996,7 @@ long TMov_mag::renum(long numdoc)
 {
   if (numdoc <= 0)
     numdoc  = atoi(get_next_key());
-	char num[16]; sprintf(num, "%ld", numdoc);
+  char num[16]; sprintf(num, "%ld", numdoc);
   renum_key("NUMREG", num);       // Aggiorna testata
   return numdoc;
 }
@@ -1003,79 +1004,79 @@ long TMov_mag::renum(long numdoc)
 // copia la chiave dal file principale a quello delle righe
 void TMov_mag::copy_linekey(const TRectype & headrec, TRectype  & linesrec)
 {
-	// ...qui basta una put tra Rectype....
-	linesrec.put("NUMREG",headrec.get("NUMREG"))	;
+  // ...qui basta una put tra Rectype....
+  linesrec.put("NUMREG",headrec.get("NUMREG"))  ;
 } 
 
-int TMov_mag::read(TBaseisamfile& f, word op , word lockop, TDate& atdate)
+int TMov_mag::read(TBaseisamfile& f, word op , word lockop)
 {
-	TToken_string l_key;
-	TLine_movmag l_data;
-	
-	int res=THead_lines_record::read(f,op,lockop,atdate);
-	// reset delle strutture per il controlli delle variazioni dei saldi
-	_codcaus=get("CODCAUS");
-	_annoes=get("ANNOES");
-	lines_to_add.destroy();	  
-	lines_to_subtract.destroy();
-	for (int i=0; i<rows(); i++) {
-		l_key=line2key(i+1);
-		l_data=line2data(i+1);
-		delete_line(l_key,l_data);    
-	}
-	return res;
+  TToken_string l_key;
+  TLine_movmag l_data;
+  
+  int res=THead_lines_record::read(f,op,lockop);
+  // reset delle strutture per il controlli delle variazioni dei saldi
+  _codcaus=get("CODCAUS");
+  _annoes=get("ANNOES");
+  lines_to_add.destroy();   
+  lines_to_subtract.destroy();
+  for (int i=0; i<rows(); i++) {
+    l_key=line2key(i+1);
+    l_data=line2data(i+1);
+    delete_line(l_key,l_data);    
+  }
+  return res;
 }
 
 
-int TMov_mag::remove(TBaseisamfile& f, TDate& atdate ) const 
+int TMov_mag::remove(TBaseisamfile& f) const 
 {
   int res;
-  if ((res=THead_lines_record::remove(f,atdate))==NOERR ) 
-  	// effettua la variazione dei saldi
-  	res=update_balances();	
-	return res;
+  if ((res=THead_lines_record::remove(f))==NOERR ) 
+    // effettua la variazione dei saldi
+    res=update_balances();  
+  return res;
 }
 
-int TMov_mag::write(TBaseisamfile& f, TDate& atdate ) const 
+int TMov_mag::write(TBaseisamfile& f) const 
 {
   int res;
-	TToken_string l_key;
-	TLine_movmag l_data;
-	// memorizza le variazioni
-	for (int i=0; i<rows(); i++) {
-		l_key=line2key(i+1);
-		l_data=line2data(i+1);
-		((TMov_mag *)this)->insert_line(l_key,l_data);    
-	}
-  if ((res=THead_lines_record::write(f,atdate))==NOERR ) 
-  	// effettua la variazione dei saldi
-  	res=update_balances();	
-	return res;
+  TToken_string l_key;
+  TLine_movmag l_data;
+  // memorizza le variazioni
+  for (int i=0; i<rows(); i++) {
+    l_key=line2key(i+1);
+    l_data=line2data(i+1);
+    ((TMov_mag *)this)->insert_line(l_key,l_data);    
+  }
+  if ((res=THead_lines_record::write(f))==NOERR ) 
+    // effettua la variazione dei saldi
+    res=update_balances();  
+  return res;
 }
 
-int TMov_mag::rewrite(TBaseisamfile& f, TDate& atdate ) const 
+int TMov_mag::rewrite(TBaseisamfile& f) const 
 {
   int res;
-	TToken_string l_key;
-	TLine_movmag l_data;
-	// memorizza le variazioni
-	for (int i=0; i<rows(); i++) {
-		l_key=line2key(i+1);
-		l_data=line2data(i+1);
-		((TMov_mag *)this)->insert_line(l_key,l_data);    
-	}
-  if ((res=THead_lines_record::rewrite(f,atdate))==NOERR ) 
-  	// effettua la variazione dei saldi
-  	res=update_balances();	
-	return res;
+  TToken_string l_key;
+  TLine_movmag l_data;
+  // memorizza le variazioni
+  for (int i=0; i<rows(); i++) {
+    l_key=line2key(i+1);
+    l_data=line2data(i+1);
+    ((TMov_mag *)this)->insert_line(l_key,l_data);    
+  }
+  if ((res=THead_lines_record::rewrite(f))==NOERR ) 
+    // effettua la variazione dei saldi
+    res=update_balances();  
+  return res;
 }
 
 const char *TMov_mag::get_next_key()  
 {
- 	TLocalisamfile f(LF_MOVMAG);
-	f.last();
-	int a=atoi(f.get("NUMREG"))+1;
-	return _nextcod.format("%d",a);
+  TLocalisamfile f(LF_MOVMAG);
+  f.last();
+  int a=atoi(f.get("NUMREG"))+1;
+  return _nextcod.format("%d",a);
 }
 
 
@@ -1091,231 +1092,231 @@ const char *TMov_mag::get_next_key()
 //
 TLine_movmag TMov_mag::line2data(int numriga) const
 {
-		TLine_movmag		rest;
-		rest.um=row(numriga).get("UM");
-		rest.quant=(const char *)row(numriga).get("QUANT");
-		rest.prezzo=(const char *)row(numriga).get("PREZZO");
-		return rest;
+    TLine_movmag    rest;
+    rest.um=row(numriga).get("UM");
+    rest.quant=(const char *)row(numriga).get("QUANT");
+    rest.prezzo=(const char *)row(numriga).get("PREZZO");
+    return rest;
 }
 
 TToken_string TMov_mag::line2key(int numriga) const
 {
-		TToken_string key;
-		key.add(row(numriga).get("CODART"));
-		key.add(row(numriga).get("CODMAG"));
-		key.add(row(numriga).get("LIVGIAC"));
-		return key;
+    TToken_string key;
+    key.add(row(numriga).get("CODART"));
+    key.add(row(numriga).get("CODMAG"));
+    key.add(row(numriga).get("LIVGIAC"));
+    return key;
 }
 
 TString TMov_mag::key2field(TToken_string &key,const char *fieldname) 
 {
-		if (strcmp(fieldname,"CODART")==0)
-			return key.get(0);
-		if (strcmp(fieldname,"CODMAG")==0)
-			return key.get(1);
-		if (strcmp(fieldname,"LIVGIAC")==0)
-			return key.get(2);
+    if (strcmp(fieldname,"CODART")==0)
+      return key.get(0);
+    if (strcmp(fieldname,"CODMAG")==0)
+      return key.get(1);
+    if (strcmp(fieldname,"LIVGIAC")==0)
+      return key.get(2);
     CHECKS(FALSE, "Nome di campo non appartenente al file righe mov ", fieldname);
-	return "";
+  return "";
 }
 
 
 int TMov_mag::insert_line(TToken_string &k,TLine_movmag &r)
 {
-	if (_codcaus != get("CODCAUS") || _annoes != get("ANNOES")) {
-		lines_to_add.add(k,r);
-	} else {
-		if (lines_to_subtract.is_key(k)&& (TLine_movmag &)lines_to_subtract[k]==r)
-			// modifica annullata
-			lines_to_subtract.remove(k);
-		else			
-			// linea modificata
-			lines_to_add.add(k,r);
-	}
-	return 0;
+  if (_codcaus != get("CODCAUS") || _annoes != get("ANNOES")) {
+    lines_to_add.add(k,r);
+  } else {
+    if (lines_to_subtract.is_key(k)&& (TLine_movmag &)lines_to_subtract[k]==r)
+      // modifica annullata
+      lines_to_subtract.remove(k);
+    else      
+      // linea modificata
+      lines_to_add.add(k,r);
+  }
+  return 0;
 }
 
 int TMov_mag::delete_line(TToken_string &k,TLine_movmag &r)
 {
-	if (_codcaus != get("CODCAUS") || _annoes != get("ANNOES")) {
-		lines_to_subtract.add(k,r);
-	} else {
-		if (lines_to_add.is_key(k)&& r==(TLine_movmag &)lines_to_add[k] )
-			// modifica annullata
-			lines_to_add.remove(k);	
-		else
-			// linea modificata
-			lines_to_subtract.add(k,r);
-	}
-	return 0;
+  if (_codcaus != get("CODCAUS") || _annoes != get("ANNOES")) {
+    lines_to_subtract.add(k,r);
+  } else {
+    if (lines_to_add.is_key(k)&& r==(TLine_movmag &)lines_to_add[k] )
+      // modifica annullata
+      lines_to_add.remove(k); 
+    else
+      // linea modificata
+      lines_to_subtract.add(k,r);
+  }
+  return 0;
 }
 
 bool TMov_mag::unlock_anamag(const char *codart) 
 {
-	TLocalisamfile anamag(LF_ANAMAG);
-	anamag.put("CODART",codart);
-	return (anamag.read(_isequal,_unlock)==NOERR);
+  TLocalisamfile anamag(LF_ANAMAG);
+  anamag.put("CODART",codart);
+  return (anamag.read(_isequal,_unlock)==NOERR);
 }
 
 bool TMov_mag::lock_anamag(const char *codart) 
 {
-	TLocalisamfile anamag(LF_ANAMAG);
-	anamag.put("CODART",codart);
-	bool insert_new=TRUE;
-	TString mess;
-	mess << "Il record di anagrafica dell'articolo ''"<< codart << "'' risulta essere già in uso.\n Interrompo ?";
-	TTimed_breakbox bbox((const char *)mess,10);
-	do {
-		if (anamag.read(_isequal,_testandlock)==NOERR) 
-			return TRUE;
-	} while (bbox.run()!=K_ESC);
-	return FALSE;
+  TLocalisamfile anamag(LF_ANAMAG);
+  anamag.put("CODART",codart);
+  bool insert_new=TRUE;
+  TString mess;
+  mess << "Il record di anagrafica dell'articolo ''"<< codart << "'' risulta essere già in uso.\n Interrompo ?";
+  TTimed_breakbox bbox((const char *)mess,10);
+  do {
+    if (anamag.read(_isequal,_testandlock)==NOERR) 
+      return TRUE;
+  } while (bbox.run()!=K_ESC);
+  return FALSE;
 }
 
 
 void TMov_mag::giac_putkey2(TLocalisamfile & mag,TString16 annoes,TToken_string curr_key) 
 {
-	mag.zero(' ');		
-	mag.put("ANNOES",annoes);
-	mag.put("CODMAG",key2field(curr_key,"CODMAG"));
-	mag.put("CODART",key2field(curr_key,"CODART"));
-	mag.put("LIVELLO",key2field(curr_key,"LIVGIAC"));
+  mag.zero(' ');    
+  mag.put("ANNOES",annoes);
+  mag.put("CODMAG",key2field(curr_key,"CODMAG"));
+  mag.put("CODART",key2field(curr_key,"CODART"));
+  mag.put("LIVELLO",key2field(curr_key,"LIVGIAC"));
 }
 
 
 // aggiorna tutti i saldi in base alle modifiche fatte.
-// 			il lock su anagrafica dovrebbe garantire il lock su tutte le 
-// 			giacenze dell'articolo
+//      il lock su anagrafica dovrebbe garantire il lock su tutte le 
+//      giacenze dell'articolo
 int TMov_mag::update_balances() const 
 {
-	bool updated_bal=TRUE;
-	TLocalisamfile mag(LF_MAG);
-	mag.setkey(2);
+  bool updated_bal=TRUE;
+  TLocalisamfile mag(LF_MAG);
+  mag.setkey(2);
 
 
-	TString_array keys_to_add,keys_to_remove;
-	((TMov_mag *)this)->lines_to_add.get_keys(keys_to_add);
-	((TMov_mag *)this)->lines_to_subtract.get_keys(keys_to_remove);
+  TString_array keys_to_add,keys_to_remove;
+  ((TMov_mag *)this)->lines_to_add.get_keys(keys_to_add);
+  ((TMov_mag *)this)->lines_to_subtract.get_keys(keys_to_remove);
 
-	// aggiunge i saldi nuovi
-	keys_to_add.sort();
+  // aggiunge i saldi nuovi
+  keys_to_add.sort();
   TToken_string * curr_key=(TToken_string *)keys_to_add.first_item();
 
-	while (curr_key) {
-		if (lock_anamag(key2field(*curr_key,"CODART"))) {
-			// lock gained
-			giac_putkey2(mag,get("ANNOES"),*curr_key);
-			if (mag.read()!=NOERR) {
-				// non trovato: aggiungo
-				giac_putkey2(mag,get("ANNOES"),*curr_key);
-				mag.put("NRIGA",giac_last_item(get("ANNOES"),key2field(*curr_key,"CODART"))+1);
-				mag.write();
-			} 
-			// modifica questo record (e lo sblocca)
-			update_balances(mag.curr(),(TLine_movmag &)lines_to_add[*curr_key],get("CODCAUS"),+1);
-			/*// ottimizzazione :(cerca di sfruttare la lettura fatta per un eventuale saldo vecchio)
-			// ciò causa la modifica dell'oggetto TMov_mag (il metodo non è più const)
-			if (_annoes == get("ANNOES") 
-					&& lines_to_subtract.is_key(*curr_key)) {
-				update_balances(mag.curr(),(TLine_movmag &)lines_to_subtract[*curr_key],_codcaus,-1);
-				((TMov_mag *)this)->lines_to_add.remove(*curr_key);
-				((TMov_mag *)this)->lines_to_subtract.remove(*curr_key);
-			}*/
-			mag.rewrite();
-			// conclude la TRANSAZIONE prima di sbloccare il record dell'articolo
-		  TToken_string *rem_key=(TToken_string *)keys_to_remove.first_item();
-			while ( rem_key) {
-				if (key2field(*rem_key,"CODART")==key2field(*curr_key,"CODART")) {
-					giac_putkey2(mag,_annoes,*rem_key);
-					if (mag.read()==NOERR) {
-						update_balances(mag.curr(),(TLine_movmag &)lines_to_subtract[*rem_key],_codcaus,-1);
-						mag.rewrite();
-		  		}	
-					keys_to_remove.remove_item();
-				}				
-				rem_key=(TToken_string *)keys_to_remove.succ_item();
-			} 
-			unlock_anamag(key2field(*curr_key,"CODART"));
-	  }	else {
-	  	updated_bal=FALSE;
-		}
-	  curr_key=(TToken_string *)keys_to_add.succ_item();
-	} 
-	// togli i saldi vecchi
+  while (curr_key) {
+    if (lock_anamag(key2field(*curr_key,"CODART"))) {
+      // lock gained
+      giac_putkey2(mag,get("ANNOES"),*curr_key);
+      if (mag.read()!=NOERR) {
+        // non trovato: aggiungo
+        giac_putkey2(mag,get("ANNOES"),*curr_key);
+        mag.put("NRIGA",giac_last_item(get("ANNOES"),key2field(*curr_key,"CODART"))+1);
+        mag.write();
+      } 
+      // modifica questo record (e lo sblocca)
+      update_balances(mag.curr(),(TLine_movmag &)lines_to_add[*curr_key],get("CODCAUS"),+1);
+      /*// ottimizzazione :(cerca di sfruttare la lettura fatta per un eventuale saldo vecchio)
+      // ciò causa la modifica dell'oggetto TMov_mag (il metodo non è più const)
+      if (_annoes == get("ANNOES") 
+          && lines_to_subtract.is_key(*curr_key)) {
+        update_balances(mag.curr(),(TLine_movmag &)lines_to_subtract[*curr_key],_codcaus,-1);
+        ((TMov_mag *)this)->lines_to_add.remove(*curr_key);
+        ((TMov_mag *)this)->lines_to_subtract.remove(*curr_key);
+      }*/
+      mag.rewrite();
+      // conclude la TRANSAZIONE prima di sbloccare il record dell'articolo
+      TToken_string *rem_key=(TToken_string *)keys_to_remove.first_item();
+      while ( rem_key) {
+        if (key2field(*rem_key,"CODART")==key2field(*curr_key,"CODART")) {
+          giac_putkey2(mag,_annoes,*rem_key);
+          if (mag.read()==NOERR) {
+            update_balances(mag.curr(),(TLine_movmag &)lines_to_subtract[*rem_key],_codcaus,-1);
+            mag.rewrite();
+          } 
+          keys_to_remove.remove_item();
+        }       
+        rem_key=(TToken_string *)keys_to_remove.succ_item();
+      } 
+      unlock_anamag(key2field(*curr_key,"CODART"));
+    } else {
+      updated_bal=FALSE;
+    }
+    curr_key=(TToken_string *)keys_to_add.succ_item();
+  } 
+  // togli i saldi vecchi
   curr_key=(TToken_string *)keys_to_remove.first_item();
 
-	while (curr_key) {
-		if (lock_anamag(key2field(*curr_key,"CODART"))) {
-			giac_putkey2(mag,_annoes,*curr_key);
-			// modifica questo record (e lo sblocca)
-			if (mag.read()==NOERR) {
-				update_balances(mag.curr(),(TLine_movmag &)lines_to_subtract[*curr_key],_codcaus,-1);
-				mag.rewrite();
-		  }	
-			unlock_anamag(key2field(*curr_key,"CODART"));
-	  }	else {
-	  	updated_bal=FALSE;
-	  }
- 		curr_key=(TToken_string *)keys_to_remove.succ_item();
-	}
-	if (!updated_bal) {
-		// saldi non aggiornati
-		warning_box("I saldi di magazzino non sono stati del tutto aggiornati. \nProcedere ad una operazione di ''Ricostruzione saldi''");
-	}
-	return 0;
+  while (curr_key) {
+    if (lock_anamag(key2field(*curr_key,"CODART"))) {
+      giac_putkey2(mag,_annoes,*curr_key);
+      // modifica questo record (e lo sblocca)
+      if (mag.read()==NOERR) {
+        update_balances(mag.curr(),(TLine_movmag &)lines_to_subtract[*curr_key],_codcaus,-1);
+        mag.rewrite();
+      } 
+      unlock_anamag(key2field(*curr_key,"CODART"));
+    } else {
+      updated_bal=FALSE;
+    }
+    curr_key=(TToken_string *)keys_to_remove.succ_item();
+  }
+  if (!updated_bal) {
+    // saldi non aggiornati
+    warning_box("I saldi di magazzino non sono stati del tutto aggiornati. \nProcedere ad una operazione di ''Ricostruzione saldi''");
+  }
+  return 0;
 }
 
 // aggiorna i saldi del record corrente 
 // in base alla causale e alla modifica fatta (con segno + o -)
 int TMov_mag::update_balances(TRectype & magrec, const TLine_movmag &l,TString16 codcaus,int rett_sign) const
 {
-	TCausale_magazzino caus(codcaus);
-	TLocalisamfile anamag(LF_ANAMAG);
-	TLocalisamfile umart(LF_UMART);
-	real diff,diff_val;
-	umart.put("CODART",magrec.get("CODART"));
-	umart.put("UM",l.um);
-	umart.read();
-	real fc=umart.get_real("FC");
+  TCausale_magazzino caus(codcaus);
+  TLocalisamfile anamag(LF_ANAMAG);
+  TLocalisamfile umart(LF_UMART);
+  real diff,diff_val;
+  umart.put("CODART",magrec.get("CODART"));
+  umart.put("UM",l.um);
+  umart.read();
+  real fc=umart.get_real("FC");
 
-	diff=fc*rett_sign*l.quant;
-	diff_val=diff*l.prezzo;
-	update_balance(magrec,"GIAC",diff*caus.sgn(s_giac)); // update ..
-	update_balance(magrec,"ACQ",diff*caus.sgn(s_acq)); // update ..
-	update_balance(magrec,"VALACQ",diff_val*caus.sgn(s_acq)); // update ..
-	update_balance(magrec,"ENT",diff*caus.sgn(s_ent));
-	update_balance(magrec,"VALENT",diff_val*caus.sgn(s_ent));
-	update_balance(magrec,"VEN",diff*caus.sgn(s_ven));
-	update_balance(magrec,"VALVEN",diff_val*caus.sgn(s_ven));
-	update_balance(magrec,"USC",diff*caus.sgn(s_usc));
-	update_balance(magrec,"VALUSC",diff_val*caus.sgn(s_usc));
-	update_balance(magrec,"ORDC",diff*caus.sgn(s_ordc));
-	update_balance(magrec,"VALORDC",diff_val*caus.sgn(s_ordc));
-	update_balance(magrec,"ORDF",diff*caus.sgn(s_ordf));
-	update_balance(magrec,"VALORDF",diff_val*caus.sgn(s_ordf));
-	update_balance(magrec,"RIM",diff*caus.sgn(s_rim));
-	update_balance(magrec,"VALRIM",diff_val*caus.sgn(s_rim));
-	update_balance(magrec,"SCARTI",diff*caus.sgn(s_scart));
-	update_balance(magrec,"VALSCARTI",diff_val*caus.sgn(s_scart));
-	update_balance(magrec,"INCL",diff*caus.sgn(s_incl));
-	update_balance(magrec,"ACL",diff*caus.sgn(s_acl));
-	update_balance(magrec,"PRODCOMP",diff*caus.sgn(s_prodc));
-	update_balance(magrec,"PRODFIN",diff*caus.sgn(s_prodf));
-	update_balance(magrec,"NLABEL",diff*caus.sgn(s_label));
-	return 0;
+  diff=fc*rett_sign*l.quant;
+  diff_val=diff*l.prezzo;
+  update_balance(magrec,"GIAC",diff*caus.sgn(s_giac)); // update ..
+  update_balance(magrec,"ACQ",diff*caus.sgn(s_acq)); // update ..
+  update_balance(magrec,"VALACQ",diff_val*caus.sgn(s_acq)); // update ..
+  update_balance(magrec,"ENT",diff*caus.sgn(s_ent));
+  update_balance(magrec,"VALENT",diff_val*caus.sgn(s_ent));
+  update_balance(magrec,"VEN",diff*caus.sgn(s_ven));
+  update_balance(magrec,"VALVEN",diff_val*caus.sgn(s_ven));
+  update_balance(magrec,"USC",diff*caus.sgn(s_usc));
+  update_balance(magrec,"VALUSC",diff_val*caus.sgn(s_usc));
+  update_balance(magrec,"ORDC",diff*caus.sgn(s_ordc));
+  update_balance(magrec,"VALORDC",diff_val*caus.sgn(s_ordc));
+  update_balance(magrec,"ORDF",diff*caus.sgn(s_ordf));
+  update_balance(magrec,"VALORDF",diff_val*caus.sgn(s_ordf));
+  update_balance(magrec,"RIM",diff*caus.sgn(s_rim));
+  update_balance(magrec,"VALRIM",diff_val*caus.sgn(s_rim));
+  update_balance(magrec,"SCARTI",diff*caus.sgn(s_scart));
+  update_balance(magrec,"VALSCARTI",diff_val*caus.sgn(s_scart));
+  update_balance(magrec,"INCL",diff*caus.sgn(s_incl));
+  update_balance(magrec,"ACL",diff*caus.sgn(s_acl));
+  update_balance(magrec,"PRODCOMP",diff*caus.sgn(s_prodc));
+  update_balance(magrec,"PRODFIN",diff*caus.sgn(s_prodf));
+  update_balance(magrec,"NLABEL",diff*caus.sgn(s_label));
+  return 0;
 }
 
 
 void TMov_mag::update_balance(TRectype & magrec, const char * fieldname, real diff) const
 {
-	magrec.put(fieldname,magrec.get_int(fieldname)+diff);
+  magrec.put(fieldname,magrec.get_int(fieldname)+diff);
 }
 
-
+HIDDEN TEsercizi_contabili _esercizi;
 
 int TMov_mag::codice_esercizio(TDate &d)
 {
-	return _esercizi.date2esc(d);
+  return _esercizi.date2esc(d);
 }
 
 
diff --git a/mg/mglib01.h b/mg/mglib01.h
index bdc255024..e916218f4 100755
--- a/mg/mglib01.h
+++ b/mg/mglib01.h
@@ -21,26 +21,26 @@ class THead_lines_record : public TAuto_variable_rectype {
   // @ cmember flag indicatore  di record nuovo
   bool _nuovo;
   // @ cmember file principale  
-  int _file;		
+  int _file;    
   // @ cmember file delle righe
-  int _rfile;		
+  int _rfile;   
   // @ cmember nome del campo "numeratore" delle righe
-	TString _numfield; 
+  TString _numfield; 
 
 
 protected:
   // @ cmember restituisce la riga del corpo
   virtual TRectype & row(int index) const;  
-	virtual void put_str(const char* fieldname, const char* val); 
-	// @ cmember funzione per estrarre dal record della testata la chiave delle righe
+  virtual void put_str(const char* fieldname, const char* val); 
+  // @ cmember funzione per estrarre dal record della testata la chiave delle righe
   virtual void copy_linekey(const TRectype & headrecord, TRectype & linesrecord)=0; 
   // @ cmember renumer la chiave del corpo
-	virtual long renum(long numdoc=-1)=0; 
+  virtual long renum(long numdoc=-1)=0; 
 
   int write_rewrite(TBaseisamfile& f ,bool re = FALSE) const ;
 public:
-	//***********************
-	// struttura
+  //***********************
+  // struttura
   // @ cmember restituisce il record di testata
   const TAuto_variable_rectype& head() const { return *this; } // Ritorna la testata del documento
   // @ cmember restituisce il record di testata
@@ -53,22 +53,22 @@ public:
   
   // @ cmember restituisce il record n-esimo del del corpo
   virtual const TRectype& operator[](int index) const 
-  	{ return (const TRectype&)((THead_lines_record *)this)->row(index); }
+    { return (const TRectype&)((THead_lines_record *)this)->row(index); }
   // @ cmember restituisce il record n-esimo del del corpo
   virtual TRectype& operator[](int index) 
-  	{ return (TRectype&)row(index); } 
+    { return (TRectype&)row(index); } 
   
   TRectype & insert_row(int row, const char *tipo = NULL);
   TRectype & new_row(const char *tipo = NULL);
   bool destroy_row(int n, bool pack = FALSE) { return _rows->destroy_row(n, pack); }
   void destroy_rows() { _rows->destroy_rows(); }
   
-	//***********************
+  //***********************
   // record e I/O
   virtual void dirty_fields();
 
   virtual const char *get_next_key() =0 ;
-	virtual void renum_key(const char * kfield,const char * val);
+  virtual void renum_key(const char * kfield,const char * val);
   virtual TRectype & operator =(const TRectype & r); 
   virtual TRectype & operator =(const char * r); 
   virtual void zero(const char * fieldname);
@@ -77,43 +77,38 @@ public:
   void reset_fields(TAuto_variable_rectype & rec) { rec.remove_field(); }
   virtual void set_fields(TAuto_variable_rectype & rec);
     
-  virtual int read(TBaseisamfile& f, word op = _isequal, word lockop = _nolock, TDate& atdate = (TDate&)botime);
+  virtual int read(TBaseisamfile& f, word op = _isequal, word lockop = _nolock);
   
-  virtual int write(TBaseisamfile& f, TDate& atdate = (TDate&)botime) const ;
-  virtual int rewrite(TBaseisamfile& f, TDate& atdate = (TDate&)botime) const ;
-  virtual int remove(TBaseisamfile& f, TDate& atdate = (TDate&)botime) const ;
+  virtual int write(TBaseisamfile& f) const ;
+  virtual int rewrite(TBaseisamfile& f) const ;
+  virtual int remove(TBaseisamfile& f) const ;
 
   //**************************
   // @ cmember costruttore dal numero del file 
-	THead_lines_record(int hfn, int rfn,const char *numfield);
+  THead_lines_record(int hfn, int rfn,const char *numfield);
   // @ cmember costruttore dal file 
-	THead_lines_record(const TBaseisamfile* head_file,int rfn,const char *numfield);
+  THead_lines_record(const TBaseisamfile* head_file,int rfn,const char *numfield);
   // @ cmember costruttore dal record 
-	THead_lines_record(const TRectype & r,int rfn,const char *numfield);
+  THead_lines_record(const TRectype & r,int rfn,const char *numfield);
   // @ cmember costruttore di copia 
-	THead_lines_record(const THead_lines_record& r);
-	virtual ~THead_lines_record();
+  THead_lines_record(const THead_lines_record& r);
+  virtual ~THead_lines_record();
 };
 
 //**********************
 // classe per la gestione delle finestre temporizzate
 class TTimed_box: public TMask
 {
- 	long _timer_delay;
- 	long _timer_id;
- 	short _button_id;
+  long _timer_delay;
+  long _timer_id;
+  short _button_id;
 protected:
-	virtual void handler(WINDOW win, EVENT* ep);
-	virtual void start_run();
+  virtual void handler(WINDOW win, EVENT* ep);
+  virtual void start_run();
 public:
-	TTimed_box(const char * header,const char * message,int seconds,short button_id,int x,int y);
+  TTimed_box(const char * header,const char * message,int seconds,short button_id,int x,int y);
 };
 
-
-
-
-
-
 // **************************************
 // **************************************
 // **************************************
@@ -122,30 +117,30 @@ public:
 // *******************************
 // LIBRERIA DI utility del magazzino
 // *******************************
-#include "..\cg\cglib.h"
 //#include "..\ve\velib03.h"
 
 
 #define MANY_MAG_LEV 10
+#define MAX_GIAC_LEVEL 4
 class TMag_livelli {
-	bool  			_enabled[MANY_MAG_LEV];
-	int 				_code_lenght[MANY_MAG_LEV];
-	TString 		_name[MANY_MAG_LEV];
-	TString 		_picture[MANY_MAG_LEV];
-	int _last_level;
-		
+  bool        _enabled[MANY_MAG_LEV];
+  int         _code_lenght[MANY_MAG_LEV];
+  TString     _name[MANY_MAG_LEV];
+  TString     _picture[MANY_MAG_LEV];
+  int _last_level;
+    
 public:
-	int last_level() const {return _last_level;}; // Ritorna il numero di livelli abilitati
-	const bool enabled(int levnum=1); // Ritorna se il livello è abilitato
-	const	TString & name(int levnum);   // Ritorna il nome (descrizione) di quel livello
-	const	TString & picture(int levnum);// Ritorna la stringa di picture per i codici gruppo di quel livello
-	const int code_lenght(int levnum);  		// Ritorna la lunghezza dei codici gruppo di quel livello
-	
-	void pack_grpcode(TString & pc, const TString &codlev, const int levnum);  		// Inserisce il codice del gruppo del livello levnum in pc
-  TString unpack_grpcode(const TString & pc, const int levnum);  		// Estrae il codice del gruppo del livello levnum da pc
+  int last_level() const {return _last_level;}; // Ritorna il numero di livelli abilitati
+  const bool enabled(int levnum=1); // Ritorna se il livello è abilitato
+  const TString & name(int levnum);   // Ritorna il nome (descrizione) di quel livello
+  const TString & picture(int levnum);// Ritorna la stringa di picture per i codici gruppo di quel livello
+  const int code_lenght(int levnum);      // Ritorna la lunghezza dei codici gruppo di quel livello
+  
+  void pack_grpcode(TString & pc, const TString &codlev, const int levnum);     // Inserisce il codice del gruppo del livello levnum in pc
+  TString unpack_grpcode(const TString & pc, const int levnum);     // Estrae il codice del gruppo del livello levnum da pc
 
-	TMag_livelli(const char *tabname);  // costruttore
-	~TMag_livelli() {}; // distruttore
+  TMag_livelli(const char *tabname);  // costruttore
+  ~TMag_livelli() {}; // distruttore
 };
 
 
@@ -154,62 +149,62 @@ public:
 #define MAXSIMBOLS 256
 #define MAXSTATES 25
 class TStateset {
-	unsigned char _container[MAXSTATES];
-	int _current;
+  unsigned char _container[MAXSTATES];
+  int _current;
 public:
-	TStateset & empty();
-	TStateset & enclose(int e);
-	TStateset & singleton(int e);
-	TStateset & cap(TStateset & s);
-	int get_first() ;
-	int get_next() ;
-	bool is_empty() const;
-	bool is_member(int e) const;
-	TStateset(); 	
-	~TStateset() {}; 	
+  TStateset & empty();
+  TStateset & enclose(int e);
+  TStateset & singleton(int e);
+  TStateset & cap(TStateset & s);
+  int get_first() ;
+  int get_next() ;
+  bool is_empty() const;
+  bool is_member(int e) const;
+  TStateset();  
+  ~TStateset() {};  
 };
 
 struct TAutoma_state  {
-	short _transaction[MAXSIMBOLS];
-	TString16 * _label;
-	bool _final;
+  short _transaction[MAXSIMBOLS];
+  TString16 * _label;
+  bool _final;
 };
 
 // *******************************
 // *******************************
 // automa per il riconoscimento di metacaratteri
 class TR_automa {
-	TAutoma_state st[MAXSTATES];
-	short _maxstate;
-protected:	
-	TStateset union_of_closures(TStateset &s);
+  TAutoma_state st[MAXSTATES];
+  short _maxstate;
+protected:  
+  TStateset union_of_closures(TStateset &s);
 
-	bool is_final(int statenum) const;
-	bool is_final(TStateset states) const;
+  bool is_final(int statenum) const;
+  bool is_final(TStateset states) const;
 
-	TR_automa & set_label(int statenum, const char *label);
-	bool is_state(int statenum);
-	const char *label(int statenum);
-	int label2state(const char * label);
+  TR_automa & set_label(int statenum, const char *label);
+  bool is_state(int statenum);
+  const char *label(int statenum);
+  int label2state(const char * label);
 
-	void del_trans(int statenum,unsigned char symbol);
-	int trans_to(int statenum,unsigned char symbol);
-	bool _isdeterministic;
-	
+  void del_trans(int statenum,unsigned char symbol);
+  int trans_to(int statenum,unsigned char symbol);
+  bool _isdeterministic;
+  
 public:
-	TR_automa & reset_state(int statenum=-1);
+  TR_automa & reset_state(int statenum=-1);
 
-	void add_tran(int statenum,unsigned char symbol,int next);// aggiunge una transizione
-	int add_state(const char * label);// aggiunge uno stato
-	TR_automa & set_final(int statenum,bool v=TRUE); // pone lo stato come finale
+  void add_tran(int statenum,unsigned char symbol,int next);// aggiunge una transizione
+  int add_state(const char * label);// aggiunge uno stato
+  TR_automa & set_final(int statenum,bool v=TRUE); // pone lo stato come finale
 
-	bool is_deterministic() {return _isdeterministic;};	// 
-	bool recognized(const char * s);					// tenta di riconoscere la stringa passata
+  bool is_deterministic() {return _isdeterministic;}; // 
+  bool recognized(const char * s);          // tenta di riconoscere la stringa passata
 
-	TR_automa(TR_automa *a=NULL,bool makedet=FALSE); // duplica un automa (e lo rende deterministico)
-	~TR_automa();
-	static void set2label(const TStateset ss,TString16 & label);
-	static void label2set(const TString16 & label,TStateset & ss);
+  TR_automa(TR_automa *a=NULL,bool makedet=FALSE); // duplica un automa (e lo rende deterministico)
+  ~TR_automa();
+  static void set2label(const TStateset ss,TString16 & label);
+  static void label2set(const TString16 & label,TStateset & ss);
 
 };
 
@@ -218,50 +213,50 @@ public:
 // *******************************
 // riconoscimento di metacaratteri
 class TMetachar {
-	TR_automa * _au;
-	TString _language;
-	char _metach_mand[10];
-	char _metach_opz[10];
+  TR_automa * _au;
+  TString _language;
+  char _metach_mand[10];
+  char _metach_opz[10];
 
-	void set_language(const char * language);	// setta l'automa che ricosce il linguaggio passato
-	void add_tran(int statenum,unsigned char symbol,int next);// aggiunge le transizioni all'automa
+  void set_language(const char * language); // setta l'automa che ricosce il linguaggio passato
+  void add_tran(int statenum,unsigned char symbol,int next);// aggiunge le transizioni all'automa
 public:
-	const char * language() const;	// restituisce la stringa di metacaratteri del linguaggio riconosciuto
-	bool recognized(const char * pattern);
+  const char * language() const;  // restituisce la stringa di metacaratteri del linguaggio riconosciuto
+  bool recognized(const char * pattern);
 
-	bool has_opzchars(const char * pattern);
-	bool has_mandchars(const char * pattern);
+  bool has_opzchars(const char * pattern);
+  bool has_mandchars(const char * pattern);
 
-	int maxstrlen(const char * pattern) const;
-	const char *mand_chars() {return _metach_mand;};   
-	const char *opz_chars() {return _metach_opz;};     
-	TMetachar(const char * str);
-	TMetachar();
-	~TMetachar();
+  int maxstrlen(const char * pattern) const;
+  const char *mand_chars() {return _metach_mand;};   
+  const char *opz_chars() {return _metach_opz;};     
+  TMetachar(const char * str);
+  TMetachar();
+  ~TMetachar();
 };
   
 // *********************
 // classe che incapsula le causali di magazzino (record della tabella CAU)
 typedef enum  {
-	s_giac,
-	s_acq,s_ent,
-	s_ven,s_usc,
-	s_ordc,s_ordf,
-	s_acl,s_incl,
-	s_prodc,s_prodf,
-	s_rim,
-	s_scart,
-	s_label
+  s_giac,
+  s_acq,s_ent,
+  s_ven,s_usc,
+  s_ordc,s_ordf,
+  s_acl,s_incl,
+  s_prodc,s_prodf,
+  s_rim,
+  s_scart,
+  s_label
 } TTipo_saldomag; 
 
 class TCausale_magazzino : public TRectype {
 public:
-	const char * get_descr() {return get("S0");}
-	const char get_tipoprz() {return get_char("S6");}
-	const char get_tipomov() {return get_char("S7");}
-	const char * get_raggfisc() {return get("S8");}
-	int sgn(TTipo_saldomag fieldname) ;
-	TCausale_magazzino(const char * codice);
+  const char * get_descr() {return get("S0");}
+  const char get_tipoprz() {return get_char("S6");}
+  const char get_tipomov() {return get_char("S7");}
+  const char * get_raggfisc() {return get("S8");}
+  int sgn(TTipo_saldomag fieldname) ;
+  TCausale_magazzino(const char * codice);
 };
 
 
@@ -270,72 +265,71 @@ class TLine_movmag ; // convenience...
 
 // dati della linea di movimento di magazzino
 class TLine_movmag : public TObject {
-public:	
-	TString16 um;
-	real quant;
-	real prezzo;
-	int operator==(TLine_movmag &);
-	
-	virtual TObject* dup() const {return new TLine_movmag(*this);};
-	
-	TLine_movmag() {}; 
-	TLine_movmag(const TLine_movmag &); 
-	virtual ~TLine_movmag() {}; 
+public: 
+  TString16 um;
+  real quant;
+  real prezzo;
+  int operator==(TLine_movmag &);
+  
+  virtual TObject* dup() const {return new TLine_movmag(*this);};
+  
+  TLine_movmag() {}; 
+  TLine_movmag(const TLine_movmag &); 
+  virtual ~TLine_movmag() {}; 
 };
 
 // classe per la definizione dei movimenti di magazzino
 // ( un movimento (testata+righe) == un oggetto TMov_mag )
 class TMov_mag : public THead_lines_record {
 
-	TEsercizi_contabili _esercizi;
-	// 
-	TString16 _codcaus;
-	TString16 _annoes;
-	// 
-	TString16 _nextcod;
-	// 
-	TAssoc_array lines_to_add;	
-	TAssoc_array lines_to_subtract;	
+  // 
+  TString16 _codcaus;
+  TString16 _annoes;
+  // 
+  TString16 _nextcod;
+  // 
+  TAssoc_array lines_to_add;  
+  TAssoc_array lines_to_subtract; 
 
 protected:
   virtual void copy_linekey(const TRectype & headrecord, TRectype & linesrecord ); 
-	virtual long renum(long numdoc=-1); // rinumerazione ;
+  virtual long renum(long numdoc=-1); // rinumerazione ;
 
-	// ************ gestione saldi
-	// @member: compone le parti chiave + dati a partire dalla riga dello sheet
-	void line2key_data(int numriga, TToken_string &key,TLine_movmag &rest) const;
-	// @member: compone la chiave a partire dalla riga dello sheet
-	TToken_string line2key(int numriga) const;
-	// @member: compone la dati a partire dalla riga dello sheet
-	TLine_movmag line2data(int numriga) const;
-	// @member: estrae dalla Tokenstring della chiave i valori corrispondenti ai campi del file
-	static TString key2field(TToken_string &key,const char * f);
-	// @member: memorizza la linea come "da togliere"
-	int delete_line(TToken_string &key,TLine_movmag &rest);
-	// @member: memorizza la linea come "da aggiungere"
-	int insert_line(TToken_string &key,TLine_movmag &rest);
-	// @member: effettua l'aggiornamento dei saldi relativi alle giacenze interessate al movimento
-	int update_balances() const;
-	// @member: effettua l'aggiornamento dei saldi di una giacenza
-	int update_balances(TRectype & magrec, const TLine_movmag &l,TString16 codcaus,int sign) const;
-	// @member: effettua l'aggiornamento di un saldo di una giacenza
-	void update_balance(TRectype & magrec, const char * fieldname, real diff) const;
+  // ************ gestione saldi
+  // @member: compone le parti chiave + dati a partire dalla riga dello sheet
+  void line2key_data(int numriga, TToken_string &key,TLine_movmag &rest) const;
+  // @member: compone la chiave a partire dalla riga dello sheet
+  TToken_string line2key(int numriga) const;
+  // @member: compone la dati a partire dalla riga dello sheet
+  TLine_movmag line2data(int numriga) const;
+  // @member: estrae dalla Tokenstring della chiave i valori corrispondenti ai campi del file
+  static TString key2field(TToken_string &key,const char * f);
+  // @member: memorizza la linea come "da togliere"
+  int delete_line(TToken_string &key,TLine_movmag &rest);
+  // @member: memorizza la linea come "da aggiungere"
+  int insert_line(TToken_string &key,TLine_movmag &rest);
+  // @member: effettua l'aggiornamento dei saldi relativi alle giacenze interessate al movimento
+  int update_balances() const;
+  // @member: effettua l'aggiornamento dei saldi di una giacenza
+  int update_balances(TRectype & magrec, const TLine_movmag &l,TString16 codcaus,int sign) const;
+  // @member: effettua l'aggiornamento di un saldo di una giacenza
+  void update_balance(TRectype & magrec, const char * fieldname, real diff) const;
 
-	static void giac_putkey2(TLocalisamfile & mag,TString16 annoes,TToken_string curr_key);
-	static bool lock_anamag(const char *codart);
-	static bool unlock_anamag(const char *codart) ;
+  static void giac_putkey2(TLocalisamfile & mag,TString16 annoes,TToken_string curr_key);
+  static bool lock_anamag(const char *codart);
+  static bool unlock_anamag(const char *codart) ;
 public:
 // IO ad alto livello
   virtual const char *get_next_key() ;
-  virtual int read(TBaseisamfile& f, word op = _isequal, word lockop = _nolock, TDate& atdate = (TDate&)botime);
-	virtual int remove(TBaseisamfile& f, TDate& atdate = (TDate&)botime) const ;
-  virtual int write(TBaseisamfile& f, TDate& atdate  = (TDate&)botime) const ;
-  virtual int rewrite(TBaseisamfile& f, TDate& atdate = (TDate&)botime) const ;
-	
-	//
-	int codice_esercizio(TDate &d);
-	// costruttori e distruttori
-	TMov_mag();
-	virtual ~TMov_mag();
+  virtual int read(TBaseisamfile& f, word op = _isequal, word lockop = _nolock);
+  virtual int remove(TBaseisamfile& f) const ;
+  virtual int write(TBaseisamfile& f) const ;
+  virtual int rewrite(TBaseisamfile& f) const ;
+  
+  //
+  int codice_esercizio(TDate &d);
+  // costruttori e distruttori
+  TMov_mag();
+  virtual ~TMov_mag();
 };