#include <stdio.h>
#include <memory.h>
#include <string.h>
#include <strings.h>

#include <files.h>
#include <expr.h>
#ifndef __EXTCDECL_H
#include <extcdecl.h>
#endif
#include <utility.h>


#define BLOCKLEN 512
#define INVFLD          255

HIDDEN char _files_tmp_string[128];
 
TFile::TFile(int lenrec, int base)

{
 _file = new SecDef;
 if (_file == NULL) fatal_box("Can't allocate record file ");
 _file->IOR = NOERR;
 _len = lenrec;
 _base = base;
 _file->LockMode = _manulock;
 _file->lpos = -1;
 _file->name[0] = '\0';
}


TFile::~TFile()

{
 delete _file;
}


void TFile::open(const char* name, TFilelock lockmode)

{
  COpen(_file, (char*) name, _len, _base, lockmode);
}


bool TFile::verify(const char* name)

{
  CVerify(_file, (char*) name);
 return _file->IOR == NOERR;
}


void TFile::create(const char* name, TRecnotype nrecord)

{
  CCreate(_file, (char*) name, _len, _base, (nrecord * _len) /BLOCKLEN + 1);
}


void TFile::chsize(const char* name, TRecnotype nrecord)

{
  CChsize(_file, (char*) name, _len, _base, (nrecord * _len) /BLOCKLEN + 1);
}


void TFile::close()

{
  CClose(_file);
}


void TFile::unlink(const char* name)

{
  CDelete(_file, (char*) name);
}


void TFile::read(char* record, TRecnotype recnum, TReclock lock)

{
 _file->LenRec = _len;
 _file->BaseFil = _base;
  CRead(_file, record, recnum, lock);
}


void TFile::write(char* record, TRecnotype recnum, TReclock lock)

{
 _file->LenRec = _len;
 _file->BaseFil = _base;
  CWrite(_file, record, recnum, lock);
}


int TFile::status() const

{
 return _file->IOR;
}


TDir::TDir()

{
 _dir = new FileDes;
 if (_dir == NULL)
  fatal_box("Can't allocate dir");
 zero();
 _num = - 1;
}


TDir::~TDir()

{
 delete _dir;
}


const char* TDir::name() const

{
 return _dir->SysName;
}


const char* TDir::des() const

{
 return _dir->Des;
}


const char* TDir::expr() const

{
 return _dir->FCalc;
}


TRecnotype& TDir::eod() const

{
 return _dir->EOD;
}


TRecnotype& TDir::eox() const

{
 return _dir->EOX;
}


TRecnotype& TDir::flags() const

{
 return _dir->Flags;
}


word& TDir::len()

{
 return (word&) _dir->LenR;
}


int TDir::status(TDirtype dirop) const

{
 return fdir[dirop].IOR;
}


void TDir::set_len(const UINT16 len)
{
 _dir->LenR = len;
}

void TDir::set_eox(const RecNoType eox)
{
 _dir->EOX = eox;
}

void TDir::set(const char * name, const RecNoType eod, const RecNoType flag, const char * des, const char * calc)
{
 strncpy (_dir->SysName, name, sizeof(_dir->SysName));
 _dir->EOD = eod;
 _dir->Flags = flag;
 strncpy (_dir->Des, des, sizeof(_dir->Des));
 strncpy (_dir->FCalc, calc, sizeof(_dir->FCalc));
}

void TDir::get(int nfile, TReclock lock, TDirtype dirtype, TDirop op)

{
 int _whichdir = (dirtype == _nordir ? NORDIR : COMDIR);

 if (op == _nordirop)
  COpenFile(nfile, _dir, int(lock), _whichdir);
 else
  CGetFile(nfile, _dir, int(lock), _whichdir);
 _num = nfile;
}


void TDir::put(int nfile, TDirtype dirtype, TDirop op)

{
 int _whichdir = (dirtype == _nordir ? NORDIR : COMDIR);

 if (nfile <= 0)
  fatal_box("Bad file number %d", nfile);
 if (op == _nordirop)
  CCloseFile(nfile, _dir, _whichdir);
 else
  CPutFile(nfile, _dir, _whichdir);
}


void TDir::zero()

{
 zerofdes(_dir);
}


int TDir::items(TDirtype dirtype) const 

{
 FileDes f;
 int _whichdir = (dirtype == _nordir ? NORDIR : COMDIR);

 CGetFile(1, &f, _nolock, _whichdir);
 return (int)f.EOD;
}

TTrec::TTrec()

{
 _rec = new RecDes;
 if (_rec == NULL)
  fatal_box("Can't allocate record description");
 zero();
 _num = - 1;
}


TTrec::~TTrec()

{
 delete _rec;
}


int TTrec::compare(const TSortable& a) const

{                                          
  const TTrec& r = (const TTrec&)a;
 const int res = memcmp((const void*)_rec, (const void*)r._rec, sizeof(*_rec));
 return res;
}

void TTrec::rehash()

{
 setrdes(_rec);
}

TTrec& TTrec::operator =(const TTrec& b)

{
 _num = b._num;
 memcpy(_rec, b._rec, sizeof(*_rec));
 return *this;
}

void TTrec::get(int nfile, TDirtype dirtype)

{
 int _whichdir = (dirtype == _nordir ? NORDIR : COMDIR);

 CGetRec(nfile, _rec, _whichdir);
 _num = nfile;
}


void TTrec::put(int nfile, TDirtype dirtype)

{
 int _whichdir = (dirtype == _nordir ? NORDIR : COMDIR);

 if (nfile <= 0)
  fatal_box("Bad file number %d", nfile);
 CPutRec(nfile, _rec, _whichdir);
}


void TTrec::zero()

{
 zerordes(_rec);
}


int TTrec::status(TDirtype dirop) const

{
 return rdir[dirop].IOR;
}


int TTrec::field(const char* name) const
 
 {
 return findfld(_rec, (char*) name);

 }

const char* TTrec::fielddef(int fld) const

{
  sprintf(_files_tmp_string, "%s|%d|%d|%d", _rec->Fd[fld].Name, 
   (int) _rec->Fd[fld].TypeF, (int) _rec->Fd[fld].Len,
   (int) _rec->Fd[fld].Dec);
  return _files_tmp_string;
}

const char* TTrec::keydef(int key) const

{
  TFixed_string s(_files_tmp_string, 128);

  s = "";
  for (int j = 0 ; j < _rec->Ky[key].NkFields; j++)
  {
    const bool upper = _rec->Ky[key].FieldSeq[j] > MaxFields;
    const int nfld = _rec->Ky[key].FieldSeq[j] - (upper ? MaxFields : 0);

    if (j) s << "+";
    if (upper) s << "UPPER(";
    s << _rec->Fd[nfld].Name;
    if (_rec->Ky[key].FromCh[j] < INVFLD)
      s << format("[%d,%d]", _rec->Ky[key].FromCh[j] + 1,
    _rec->Ky[key].ToCh[j] + 1);
    if (upper) s << ")";
  }
  s << (_rec->Ky[key].DupKeys ? "|X" : "| ");
  return (const char*) s;
}

void TTrec::update_fielddef(int nfld, const char* desc)

{
  TToken_string s(desc);
  strcpy(_rec->Fd[nfld].Name, s.get());
  _rec->Fd[nfld].TypeF = s.get_int();
  _rec->Fd[nfld].Len = s.get_int();
  _rec->Fd[nfld].Dec = s.get_int();
}


void TTrec::update_keydef(int key, const char* desc)

{
  TExpression expr("", _strexpr);
  TToken_string s(desc);
  TString ke(s.get());
  
  if (expr.set((const char*) ke, _strexpr))
    {
    _rec->Ky[key].DupKeys = (*s.get() != ' ');
    TCodearray& c = expr.code();
    c.begin();
    int n = 0;
    while (!c.end())
    {
      TCode& inst = c.step();
      TCodesym sym = inst.getsym();

      if (sym == _variable)
      {
 const char* s = inst.string();
 
 for (int i = 0; i <_rec->NFields; i++)
   if (strcmp(_rec->Fd[i].Name, s) == 0) break;
 
 _rec->Ky[key].FieldSeq[n] = i;
 _rec->Ky[key].FromCh[n] = INVFLD;
 _rec->Ky[key].FromCh[n] = INVFLD;
 inst = c.step();
 sym = inst.getsym();
 if (sym == _upper)
   _rec->Ky[key].FieldSeq[n] += MaxFields;
 else
   if (sym == _number)
     {
       _rec->Ky[key].FromCh[n] = inst.number().integer() - 1;
       inst = c.step();
       _rec->Ky[key].ToCh[n] = _rec->Ky[key].FromCh[n] + inst.number().integer() - 1;
       inst = c.step();
     }
   else c.backtrace();
 n++;
      }
    }
    _rec->Ky[key].NkFields = n;
  }
}

void TTrec::print_on(ostream& out) const

{
  out << num() << '\n';
  const int nfields = fields();
  TToken_string s(80);

  out << nfields << '\n';
  for (int i = 0; i < nfields; i++)
  {
    s = fielddef(i);
    out << s << '\n';
  }
  const int nkeys = keys();

  out << nkeys << '\n';
  for (i = 0; i < nkeys; i++)
  {
    s = keydef(i);
    out << s << '\n';
  }
}


void TTrec::read_from(istream& in)

{
  int ln;

  in.getline(_files_tmp_string, sizeof(_files_tmp_string), '\n');
  ln = atoi(_files_tmp_string);
  if (ln != num() && !yesno_box("Descrizione relativa al file n.ro %d.\n Continuo ?", ln))
    return;
  int nfields;

  in.getline(_files_tmp_string, sizeof(_files_tmp_string), '\n');
  nfields = atoi(_files_tmp_string);
  set_fields(nfields);
  for (int i = 0; i < nfields; i++)
  { 
    in.getline(_files_tmp_string, sizeof(_files_tmp_string), '\n');
    update_fielddef(i, _files_tmp_string);
  }
  int nkeys;

  in.getline(_files_tmp_string, sizeof(_files_tmp_string), '\n');
  nkeys = atoi(_files_tmp_string);
  set_keys(nkeys);
  for (i = 0; i < nkeys; i++)
  {
    in.getline(_files_tmp_string, sizeof(_files_tmp_string), '\n');
    update_keydef(i, _files_tmp_string);
  }
  rehash();
}