#include "velib.h"
#include "vepriv.h"

#include <clifo.h>

#ifndef __EXPR_H
#include <expr.h>
#endif
          
#ifndef __TABUTIL_H
#include <tabutil.h>
#endif

#ifndef __VERIG_H
#include "verig.h"
#endif

#ifndef __VEUML_H
#include "veuml.h"
#endif

#ifndef __VEUML1_H
#include "veuml1.h"
#endif

#ifndef __DEFMASK_H
#include <defmask.h>
#endif

#ifndef __SCONTI_H
#include "sconti.h"             
#endif

TSpesa_prest::TSpesa_prest(const char* codice, char tipo)
       : TRectype(LF_TAB)
{
  settab(tipo == RIGA_SPESEDOC ? "SPP" : "PRS");
  if (codice && *codice)
    read(codice);
}

TSpesa_prest::TSpesa_prest(const TRectype& rec)
      : TRectype(rec)
{
}

int TSpesa_prest::read(const char* codice)
{                                   
  TTable t(get("COD"));
  put("CODTAB", codice);
  int err = TRectype::read(t);
  if (err != NOERR)
    yesnofatal_box("Tipo spesa assente : %s", codice);
  return err;  
}

TIVA::TIVA(const char* codice)
       : TRectype(LF_TABCOM)
{
  settab("IVA");
  if (codice && *codice)
    read(codice);
}

TIVA::TIVA(const TRectype& rec)
      : TRectype(rec)
{
}

int TIVA::read(const char* codice)
{                                   
  TTable t("%IVA");
  put("CODTAB", codice);
  int err = TRectype::read(t);
  if (err != NOERR)
    yesnofatal_box("Codice IVA assente : %s", codice);
  return err;  
}

bool ora_hndl( TMask_field& field, KEY key )

{
  if (field.to_check(key))
  {
    TFixed_string ora( field.get( ), 6 );
    
    ora.trim( );
    if (ora.not_empty() || field.required() )
    {
      if ( isdigit( ora[ 0 ] ) )
      {
        if ( ora[ 2 ] != ':')
        {
          if ( ora.len( ) > 4 )
            ora.overwrite( ":", 2 );
          else
            ora.insert( ":", 2 );            
        }
      }
      const bool ok = ((isdigit(ora[0]))&&(isdigit(ora[1]))&&(isdigit(ora[3]))&&(isdigit(ora[4]))) &&
                      ((atoi(&(ora[0]))<24)&&(atoi(&(ora[3]))<60));
      if (ok )
        field.set((ora));          
      else  
        return error_box("Ora errata o formato non valido");
    }
  }
  return TRUE;
}

bool dummy_hndl(TMask_field& field, KEY key)
{
  warning_box( "Al campo %d è arrivato un KEY %d", field.dlg( ), key );
  return TRUE;
}

// Handler per il calcolo delle date di pagamento
bool condpag_hndl( TMask_field& field, KEY key )
{                
  TDocumento_mask& m = (TDocumento_mask &) field.mask( );
  
  if ( field.to_check(key) || (key == K_TAB && !m.is_running()))
  {
    const TString16 condpag(m.get(F_CODPAG));
    TString16 data(m.get(F_DATAINSC));      
    
    if (data.empty())     
      data = m.get(F_DATADOC);      
    if ( condpag.not_empty())
    {
      TPagamento pag(condpag, data); 
      
      pag.set_total( 100, 10, 10 );
      pag.set_rate_auto( );      
      int numrate = pag.n_rate( );
      if (numrate > 5)
        numrate = 5;
      for( int i = 0; i < numrate; i ++ )
      {
        m.show( F_DATASCAD1 + i );
        m.set( F_DATASCAD1 + i, pag.data_rata(i).string());
      }
      for( ; i < 5; i ++ )
        m.hide( F_DATASCAD1 + i );
    }
  }
  return TRUE;
}

bool note_hndl( TMask_field& f, KEY key )
{             
  TDocumento_mask & m = (TDocumento_mask &) f.mask();

  if (key == K_TAB && (f.focusdirty() || !m.is_running()))
  {
    TTable & note = (TTable &) ((TEdit_field &) f).browse()->cursor()->file();
    note.setkey(1);
    const TString16 cod(f.get());
    
    if (cod != note.get("CODTAB"))
    {
      note.zero();
      note.put("CODTAB", cod);
      if (note.read() != NOERR)
        note.zero();
    }
    const bool reg_disabled = note.get_bool("B0");
    
    if (reg_disabled)
      message_box("Registrazione disbilitata : %s", (const char *) note.get("S0"));
    m.enable(DLG_SAVEREC, !reg_disabled);
  }
  return TRUE;
}

// Handler per il calcolo delle date di pagamento
bool data_hndl( TMask_field& field, KEY key )
{                
  TDocumento_mask& m = (TDocumento_mask &) field.mask( );
  if (key == K_ENTER && field.dirty())
  {          
    TLocalisamfile doc(LF_DOC);           
    const TDate datadoc(m.get(F_DATADOC));
    
    doc.curr() = m.doc().head(); 
    const TString16 codnum(doc.get("CODNUM"));
    const int anno = doc.get_int("ANNO");
    const char tipo_num = doc.get_char("PROVV");
    
    if (doc.read(_isgreat) == NOERR &&
        codnum == doc.get("CODNUM") &&
        anno == doc.get_int("ANNO") &&
        tipo_num == doc.get_char("PROVV") &&
        datadoc > doc.get_date("DATADOC"))
      return field.error_box("Data documento superiore alla data del documento successivo");
    
    doc.curr() = m.doc().head(); 
    doc.read();
    if (doc.prev() == NOERR &&
        codnum == doc.get("CODNUM") &&
        anno == doc.get_int("ANNO") &&
        tipo_num == doc.get_char("PROVV") &&
        datadoc < doc.get_date("DATADOC"))
      return field.error_box("Data documento inferiore alla data del documento precedente");
  }
  return TRUE;
}
  
// handler delle righe

void row_set_handler( TMask& m, const int field, const int index )
{
  switch ( index )
  {
    case 1:
      m.set_handler( field, dummy_hndl );
      break;
    default:
      yesnofatal_box( FALSE, "Funzione di handler sulla riga non definita( %d ).", index );
  }
}
                                     
HIDDEN TString16 curr_um;                                                     
HIDDEN real curr_fc(1.0);

bool iva_handler( TMask_field& f, KEY key )
{   
  if (key == 0 || (key == K_ENTER && f.get().empty()))
  {
    TDocumento_mask & mask = (TDocumento_mask &) f.mask().get_sheet()->mask();
    const TString16 codiva = mask.condv().clifo().vendite().get(CFV_ASSFIS);

    if (codiva.not_empty())
      f.set(codiva);
    f.check();
  }
  return TRUE;
}
                                       
bool codart_handler( TMask_field& f, KEY key )
{
  TMask& row_mask = f.mask();   
              
  if (f.to_check(key, TRUE))
  { 
    if (f.get().not_empty())
        row_mask.enable(FR_LIV1);
    else
    {
      row_mask.reset(FR_LIV1);
      row_mask.disable(FR_LIV1);
    }    
    row_mask.field(FR_LIV1).on_hit();
  }
  if (key == K_TAB && (f.focusdirty() || row_mask.get(FR_CHECKED).empty()))
  {            
    TDocumento_mask & mask = (TDocumento_mask &) row_mask.get_sheet()->mask();
    TCond_vendita & condv = mask.condv();
    
    condv.set_testa(&mask);
    condv.set_riga(&row_mask);

    TLocalisamfile & anamag = ((TEdit_field &) f).browse()->cursor()->file();
    TLocalisamfile & umart  = ((TEdit_field &) row_mask.field(FR_UMQTA)).browse()->cursor()->file();
    
    condv.set_anamag(anamag);
    condv.set_umart(umart);
    TString80 codart(f.get());   
    anamag.setkey(1);
    anamag.put("CODART", codart);
    bool found = anamag.read() == NOERR;
    if (found)
      row_mask.set(FR_CODARTMAG, codart, TRUE);
    else
    {
      TLocalisamfile codalt(LF_CODCORR);
      
      codalt.setkey(2);
      codalt.put("CODARTALT", codart);
      if (codalt.read() == NOERR)
      {                              
        codart = codalt.get("CODART");
        anamag.zero();
        anamag.put("CODART", codart);
        found = anamag.read() == NOERR;
        if (found)
          row_mask.set(FR_CODARTMAG, codart, TRUE);
      }
    }     
    row_mask.set(FR_CHECKED, "X");
    if (!found)
        row_mask.set(FR_CODARTMAG, "", TRUE);
    else
    {
      const TString16 lingua = mask.get(F_CODLIN);                              
      const TString codart(row_mask.get(FR_CODARTMAG));
      TString desc(anamag.get("DESCR"));
      
      if (lingua.not_empty())
      {
        TLocalisamfile deslin(LF_DESLIN);
        
        deslin.setkey(2);
        deslin.put("CODART", codart);
        deslin.put("CODLIN", lingua);
        if (deslin.read() == NOERR)
          desc = deslin.get("DESCR");
      }
      row_mask.set(FR_DESCR, desc);
                                     
      umart.setkey(1);              
      umart.zero(); 
      umart.put("CODART", codart);
      if (umart.read(_isgteq) == NOERR && codart == umart.get("CODART"))
      {
        curr_um = umart.get("UM");       
        curr_fc = umart.get_real("FC");
      }
      else
      {
        curr_um.cut(0);                  
        curr_fc = 1.0;
      }
      row_mask.set(FR_UMQTA, curr_um);
    }

    condv.ricerca();
    const int pos = row_mask.id2pos(FR_CODIVA);

    if (pos >= 0)
      iva_handler(row_mask.fld(pos), 0);
  }
  return TRUE;
}                           

bool codartmag_handler( TMask_field& f, KEY key )
{                  
  bool to_check = key == K_TAB && f.focusdirty();
  TMask & m = f.mask(); 

  if (!to_check)
  {
    TSheet_field * s = m.get_sheet();
    
    if (s)
      to_check = !s->mask().is_running();
  }
  if (to_check)
  {                            
    const bool artmag = f.get().not_empty();
    
    m.show(FR_UMQTA, artmag);
    m.show(FR_UMQTA2, !artmag);
  }
  return TRUE;
}

bool liv_handler( TMask_field& f, KEY key )
{
  if (f.to_check(key, TRUE))
  {
    TMask& row_mask = f.mask();   
    TMask_field & next = row_mask.field(f.dlg() + 1);
    if (f.get().not_empty())
      next.enable();
    else
    {
      next.reset();
      next.disable();
    }                    
    next.on_hit();
  }
  return TRUE;
}

bool umart_handler( TMask_field& f, KEY key )
{
  // Se qualcuno cerca di modificare la maschera
  if ( key == K_TAB && f.focusdirty())
  { 
    TMask& row_mask = f.mask( );               
    TDocumento_mask & mask = (TDocumento_mask &) row_mask.get_sheet()->mask();
    TLocalisamfile & anamag = ((TEdit_field &) row_mask.field(FR_CODART)).browse()->cursor()->file();
    TLocalisamfile & umart  = ((TEdit_field &) f).browse()->cursor()->file();
    TCond_vendita & condv = mask.condv();
    
    condv.set_testa(&mask);
    condv.set_riga(&row_mask);
    condv.set_anamag(anamag);
    condv.set_umart(umart);
    condv.ricerca(TRUE);

    const TString16 um(f.get());
    real fc(1.0);
    
    if (um.not_empty() && curr_um.not_empty() && um != curr_um)
    {           
      umart.setkey(2);                               
      umart.put("CODART", row_mask.get(FR_CODART));
      umart.put("UM", um);
      if (umart.read() == NOERR)
      {
        real qta(row_mask.get_real(FR_QTA));
        qta *= curr_fc;          
        fc = umart.get_real("FC");
        qta /= fc;
        row_mask.set(FR_QTA, qta);
      }
        
    }
    curr_um = um;
    curr_fc = fc;
  }   
  return TRUE;
}

bool descr_handler( TMask_field& f, KEY key )
{
  if (key == K_TAB && f.focusdirty())
  {            
    const TString s(f.get());
    if (s.find('\n') < 0)
    {
      TLocalisamfile & anamag = ((TEdit_field &) f).browse()->cursor()->file();
      
      anamag.zero();
      anamag.setkey(2);
      anamag.put("DESCR", ((TZoom_field &) f).get_first_line());
      if (anamag.read() == NOERR)
      {                         
        f.mask().set(FR_CODART, anamag.get("CODART"));
        f.mask().field(FR_CODART).set_dirty();
        f.mask().check_field(FR_CODART);
      }
    }
  }       
  return TRUE;
}

bool qta_handler( TMask_field& f, KEY key )
{                   
  // Se qualcuno cerca di modificare la maschera
  if ( key == K_TAB && f.focusdirty())
  { 
    TMask& row_mask = f.mask( );               
    TDocumento_mask & mask = (TDocumento_mask &) row_mask.get_sheet()->mask();
    TLocalisamfile & anamag = ((TEdit_field &) row_mask.field(FR_CODART)).browse()->cursor()->file();
    TLocalisamfile & umart  = ((TEdit_field &) row_mask.field(FR_UMQTA)).browse()->cursor()->file();
    TCond_vendita & condv = mask.condv();
    
    condv.set_testa(&mask);
    condv.set_riga(&row_mask);
    condv.set_anamag(anamag);
    condv.set_umart(umart);
    condv.ricerca(FALSE, TRUE);
  } 
  return TRUE;
}
  
void sppr_calc(TRectype & rec, const TString & valuta_doc, const real & cambio, real & prezzo)
{     
  const TString16 sppr_valuta(rec.get("S4"));
        
  if (sppr_valuta != valuta_doc && cambio != 0.0)
  {                           
    TTable val("%VAL");
          
    val.put("CODTAB", sppr_valuta);
    if (val.read() == NOERR)
    {
      const real sppr_cambio = val.get_real("R10");
      if (sppr_cambio != ZERO)
        prezzo *= sppr_cambio;
    }
    prezzo /= cambio;
  }
}
  
bool sppr_handler( TMask_field& f, KEY key )
{ 
  TMask& row_mask = f.mask();               
  
  if (key == K_TAB && (f.focusdirty() || row_mask.get(FR_DESCR).empty()))
  {                  
    const int pos = row_mask.id2pos(FR_PREZZO);
    
    if (pos >= 0)
    {
      TMask & mask = row_mask.get_sheet()->mask();
      TRectype & spprrec = ((TEdit_field &) row_mask.field(FR_CODART)).browse()->cursor()->file().curr();
      
      if (spprrec.get("CODTAB") == row_mask.get(FR_CODART) && spprrec.get_char("S6") != 'P')
      {
        const real cambio = mask.get(F_CAMBIO);
        real prezzo = row_mask.get(FR_PREZZO);
        const TString16 doc_valuta(mask.get(F_CODVAL));
        sppr_calc(spprrec, doc_valuta, cambio, prezzo);
        row_mask.set(FR_PREZZO, prezzo);          
        const int posiva = row_mask.id2pos(FR_CODIVA);
        if (posiva >= 0)
          iva_handler(row_mask.fld(posiva), 0);
      }
    }
  } 
  return TRUE;
}

///////////////////////////////////////////////////////////
// Funzioni per il calcolo dei prezzi netti/lordi
///////////////////////////////////////////////////////////

real lordo2netto(real& lordo, const TString& codiva, int ndec)
{
  TTable tabiva("%IVA");
  real aliquota = 0.0;
  
  tabiva.put("CODTAB", codiva);
  if (tabiva.read() == NOERR) aliquota = tabiva.get_real("R0");
  
  return lordo2netto(lordo,aliquota, ndec);
}

real netto2lordo(const real& netto, const TString& codiva, int ndec)
{
  TTable tabiva("%IVA");
  real aliquota = 0.0;
  
  tabiva.put("CODTAB", codiva);
  if (tabiva.read() == NOERR) aliquota = tabiva.get_real("R0");
  
  return netto2lordo(netto,aliquota, ndec);
}

real lordo2netto(real& lordo, const real& iva, int ndec)
{
  real netto;
  real imposta = 0.0;
  real imposta_rec = 0.0;
  if (!iva.is_zero())
  {
    imposta = (lordo * iva) / (iva + 100.0); // Calcola l'imposta...
    if (imposta < ZERO)
      imposta.floor(ndec);
    else
      imposta.ceil(ndec);
  }
  netto = lordo - imposta; // Questo e' l'importo netto
  imposta_rec = (netto * iva) / 100.0; // Ricalcola l'imposta con il nuovo imponibile
  if (imposta_rec < ZERO)
    imposta_rec.floor(ndec);
  else
    imposta_rec.ceil(ndec);
  if (imposta != imposta_rec) // In questo caso corregge l'importo lordo 
    lordo = netto + imposta_rec;
  return netto;
}

real netto2lordo(const real& netto, const real& iva, int ndec)
{
  real lordo;
  real imposta = 0.0;
  if (!iva.is_zero())
  {
    imposta = (netto * iva) / 100.0; // Calcola l'imposta
    if(imposta < ZERO)
      imposta.floor(ndec);
    else
      imposta.ceil(ndec);
  }
  lordo = imposta + netto; // prezzo lordo
  return lordo;
}

real prezzo_scontato(const real& prezzo, const char * sconto)
{    
  real scontato = prezzo;
  
  if (sconto && *sconto)
  {
    TCond_vendita cv;      

    cv.set_sconto(sconto);
    scontato = cv.sconto_val() * prezzo;
  }               
  return scontato;
} 

real iva(real imponibile, const TIVA & iva,int ndec)   
{            
   real val = imponibile * iva.aliquota() / 100.0;
                  
   if (ndec < 20)
   {               
     if (val < ZERO)
       val.floor(ndec);
     else               
       val.ceil(ndec);
   }
   return val;
}

///////////////////////////////////////////////////////////
// Formula generica
///////////////////////////////////////////////////////////
                
TExpr_documento::TExpr_documento(const char* expression, TTypeexp type,
                                 TDocumento * doc, TRiga_documento * row)
              : TExpression(type), _doc(doc), _row(row)
{
  if (!set(expression, type))
    error_box("Wrong expression : %s", expression);
}         

int TExpr_documento::parse_user_func(const char * name, int nparms) const
{    
  if (strcmp(name, "SOMMA") == 0)
    return nparms > 0 || nparms < 3 ? _somma : -1;
  else
    if (strcmp(name, "BOLLI") == 0)
      return nparms > 0 || nparms < 4 ? _bolli : -1;
    else
      if (strcmp(name, "_BOLLI") == 0)
        return nparms > 0 || nparms < 3 ? _bolli_int : -1;
      else
        if (strcmp(name, "SPESEINC") == 0)
          return nparms > 0 || nparms < 4 ? _spinc : -1;
        else
          if (strcmp(name, "PREZZO") == 0)
            return  nparms < 4 ? _prezzo : -1;
          else
            if (strcmp(name, "IMPORTO") == 0)
              return  nparms < 4 ? _importo : -1;
            else
              if (strcmp(name, "SCONTO") == 0)
                return nparms < 2 ? _sconto : -1;
              else
                if (strcmp(name, "IVA") == 0)
                  return nparms < 2 ? _iva : -1;
                else
                  if (strcmp(name, "PROVV") == 0)
                    return nparms < 2 ? _provv : -1;
                  else
                    if (strcmp(name, "TIPO") == 0)
                      return nparms == 0 ? _tipo : -1;
                    else 
                      if (strcmp(name, "IMPONIBILI") == 0)
                        return nparms < 3 ? _imponibili : -1;
                      else 
                        if (strcmp(name, "IMPOSTE") == 0)
                          return nparms < 3 ? _imposte : -1;
                        else
                          return -1;
}    

void TExpr_documento::evaluate_user_func(int index, int nparms, TEval_stack & stack, TTypeexp type) const
{                 
  switch (index)
  { 
    case _somma:
      {    
        const TString cond(nparms == 2 ? stack.pop_string() : "STR(1)");
        const TString & fieldname = stack.pop_string();
        real somma;
          
        if (_doc != NULL)
        {
          TExpr_documento cond_expr(cond, _strexpr, _doc);
          const int nrows = _doc->rows();
          const int nvars = cond_expr.numvar();
            
          for (int i = nrows; i > 0 ; i--)
          {
            TRiga_documento & riga = (TRiga_documento &) (*_doc)[i];
              
            for (int j = nvars - 1; j >= 0; j--)
            {
              const char* s = cond_expr.varname(j);
              TFieldref f(s,0);
              cond_expr.setvar(j, f.read(riga));
            }                       
            cond_expr.set_row(&riga);
            if ((bool)cond_expr)
              somma += riga.get_real(fieldname);
          }
        }
        stack.push(somma);
      }      
      break;
    case _spinc:
      {
        int ndec = _doc && _doc->in_valuta() ? 3 : 0;
        bool netto = FALSE;
        
        if (nparms > 2)
          ndec = (int) stack.pop_real().integer();
        if (nparms > 1)
          netto = !stack.pop_real().is_zero();
          
        real & r = stack.peek_real();
                  
        if (_doc)          
          r = _doc->spese_incasso(r, ndec, netto ? _netto : _lordo);
        else
          r = ZERO;
      }    
      break;
    case _bolli:
      {
        int ndec = _doc && _doc->in_valuta() ? 3 : 0;
        bool netto = FALSE;
        
        if (nparms > 2)
          ndec = (int) stack.pop_real().integer();
        if (nparms > 1)
          netto = !stack.pop_real().is_zero();
          
        real & r = stack.peek_real();
          
        if (_doc)
        {
          r += _doc->spese_incasso(r, ndec);
          r = _doc->bolli(r, ndec, netto ? _netto : _lordo);
        }
        else
          r = ZERO;
      } 
      break;
    case _bolli_int:
      {
        int ndec = _doc && _doc->in_valuta() ? 3 : 0;
        
        if (nparms > 2)
          ndec = (int) stack.pop_real().integer();
          
        real & r = stack.peek_real();
        
        if (_doc)
        {
          real r1 = _doc->spese_incasso(r, ndec);
          r += r1;
          r1 += _doc->bolli(r, ndec);
          r = r1;
        }
        else
          r = ZERO;
      } 
      break;
    case _prezzo:
      {  
        int ndec = _doc && _doc->in_valuta() ? 3 : 0;
        bool lordo = FALSE;
        bool scontato = FALSE;
  
        if (nparms > 2)
          ndec = (int) stack.pop_real().integer();
        if (nparms > 1)
          lordo = !stack.pop_real().is_zero();
        if (nparms > 0)
          scontato = !stack.peek_real().is_zero();
        else  
          stack.push(ZERO);
          
        real & val = stack.peek_real();
        if (_row)
          val = _row->prezzo(scontato, lordo, ndec);
        else val = ZERO;

      }
      break;
    case _importo:
      {  
        int ndec = _doc && _doc->in_valuta() ? 3 : 0;
        bool lordo = FALSE;
        bool scontato = FALSE;
  
        if (nparms > 2)
          ndec = (int) stack.pop_real().integer();
        if (nparms > 1)
          lordo = !stack.pop_real().is_zero();
        if (nparms > 0)
          scontato = !stack.peek_real().is_zero();
        else  
          stack.push(ZERO);

        real & val = stack.peek_real();   
        if (_row)
          val = _row->importo(scontato, lordo, ndec);
        else
          val = ZERO;
      }
      break;
    case _sconto:
      {                                       
        int ndec = _doc && _doc->in_valuta() ? 3 : 0;

        if (nparms > 0)
          ndec = (int) stack.peek_real().integer();
        else
          stack.push(ZERO);

        real & val = stack.peek_real();
        if (_row)
        {
          if (_row->is_sconto())
            val = -_row->importo(FALSE, FALSE, ndec);
          else
            val = _row->importo(FALSE, FALSE, ndec) - _row->importo(TRUE, FALSE, ndec);
        } 
        else
          val = ZERO;
      }
      break;
    case _iva:
      {  
        int ndec = _doc && _doc->in_valuta() ? 3 : 0;

        if (nparms > 0)
          ndec = (int) stack.peek_real().integer();
        else
          stack.push(ZERO);

        real & val = stack.peek_real();
                      
        if (_row)              
          val = _row->imposta();
        else
          val = ZERO;
      }
      break;
    case _provv:
      {  
        int ndec = _doc && _doc->in_valuta() ? 3 : 0;

        if (nparms > 0)
          ndec = (int) stack.peek_real().integer();
        else
          stack.push(ZERO);

        real & val = stack.peek_real();

        if (_row)
        {
          val = _row->importo(TRUE, FALSE, ndec) * _row->get_real("PERCPROV") / 100.0; 
          val.round(ndec);
        }
        else
          val = ZERO;
      }
      break;
    case _tipo:
      {
        TString s; 
        if (_row)
          s << _row->tipo().tipo();
        stack.push(s);
      }
      break;  
    case _imponibili:
      {
        int ndec = _doc && _doc->in_valuta() ? 3 : 0;
        bool spese = FALSE;
    
        if (nparms > 1)
          ndec = (int) stack.pop_real().integer();
        if (nparms > 0)
          spese = !stack.pop_real().is_zero();
        else  
          stack.push(ZERO);
        real & val = stack.peek_real();
        val = _doc->imponibile(spese, ndec);
      }
      break;
    case _imposte:
      {
        int ndec = _doc && _doc->in_valuta() ? 3 : 0;
        bool spese = FALSE;
    
        if (nparms > 1)
          ndec = (int) stack.pop_real().integer();
        if (nparms > 0)
          spese = !stack.pop_real().is_zero();
        else  
          stack.push(ZERO);
        real & val = stack.peek_real();
        val = _doc->imposta(spese, ndec);
      }
      break;
    default:
      TExpression::evaluate_user_func(index, nparms, stack, type);
      break;
  }
}    

TObject* TExpr_documento::dup() const
{
  TExpr_documento* o = new TExpr_documento(*this);
  return o;
}    

///////////////////////////////////////////////////////////
// Formula generica
///////////////////////////////////////////////////////////

TFormula_documento::TFormula_documento(TTipo_formula tipo, const char* codice, const char * expr, bool numexpr)
               : TRectype(LF_TABCOM), _expr(NULL)
{               
  _tab = tipo == _documento ? "FRD" : "FRR";
  settab(_tab);
  _tab.insert("%");
  if (codice && *codice)
    read(codice, expr, numexpr);
}

TFormula_documento::TFormula_documento(const TRectype& rec)
               : TRectype(rec), _expr(NULL)
{
  _tab = "%";
  _tab << rec.get("COD");
  _expr = new TExpr_documento(expr_string(), expr_type());
}

TFormula_documento::~TFormula_documento()
{
  if (_expr) delete _expr;
}

int TFormula_documento::read(const char* codice, const char * expr, bool numexpr)
{           
  if (_expr != NULL)
  {
    delete _expr;
    _expr = NULL;
  }

  put("CODTAB", codice);
  
  int err = NOERR;
  
  if (expr && *expr)
  {
    put("S1", expr);
    put("B0", numexpr ? "X" : "");
  }  
  else           
  {
    TTable t(_tab);

    err = TRectype::read(t);
  }
  
  if (err == NOERR)             
  {
    const TString e(expr_string());
    
    _expr = new TExpr_documento(e, expr_type());
  }
  else
  {
    zero();
    put("CODTAB", codice);
  }
  return err;  
}