Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
branch: master
Fetching contributors…

Cannot retrieve contributors at this time

904 lines (753 sloc) 17.527 kb
// file.cpp
// Revision 9-jan-2005
#include "blassic.h"
#include "file.h"
#include "trace.h"
#include "error.h"
#include "var.h"
//#include "cursor.h"
//#include "edit.h"
//#include "graphics.h"
#include "sysvar.h"
//#include "socket.h"
#include "util.h"
using util::to_string;
#include <fstream>
#include <iomanip>
#include <sstream>
#include <stdexcept>
#include <algorithm>
// para strerror (errno)
#include <string.h>
#include <errno.h>
#include <iostream>
using std::cerr;
using std::endl;
#include <cassert>
#define ASSERT assert
//***********************************************
// Auxiliary functions
//***********************************************
namespace {
BlInteger lengthoffileread (std::fstream & fs)
{
// WARNING: The C++ standard does not guarantee that
// this method obtains the length of the file.
std::streamsize old= fs.tellg ();
fs.seekg (0, std::ios::end);
std::streamsize l= fs.tellg ();
fs.seekg (old, std::ios::beg);
// Not leave the file unusable in case something were wrong.
fs.clear ();
return static_cast <BlInteger> (l);
}
BlInteger lengthoffilewrite (std::fstream & fs)
{
// WARNING: The C++ standard does not guarantee that
// this method obtains the length of the file.
std::streamsize old= fs.tellp ();
fs.seekp (0, std::ios::end);
std::streamsize l= fs.tellp ();
fs.seekp (old, std::ios::beg);
// Not leave the file unusable in case something were wrong.
fs.clear ();
return static_cast <BlInteger> (l);
}
} // namespace
namespace blassic {
namespace file {
//***********************************************
// BlFile
//***********************************************
BlFile::BlFile (OpenMode nmode) :
mode (nmode),
cDelimiter (','),
cQuote ('"'),
cEscape ('\0')
{
}
BlFile::~BlFile ()
{
}
void BlFile::closein ()
{ throw ErrFileMode; }
void BlFile::closeout ()
{ throw ErrFileMode; }
void BlFile::reset (int, int, int, int)
{ throw ErrFileMode; }
bool BlFile::istextwindow () const
{
return false;
}
bool BlFile::eof ()
{
if (showdebuginfo () )
cerr << "This file type does not implement EOF" << endl;
throw ErrFileMode;
}
size_t BlFile::loc ()
{ throw ErrFileMode; }
void BlFile::flush ()
{ throw ErrFileMode; }
void BlFile::getline (std::string &, bool)
{ throw ErrFileMode; }
void BlFile::outstring (const std::string &)
{ throw ErrFileMode; }
void BlFile::outchar (char)
{ throw ErrFileMode; }
#if 0
void BlFile::outnumber (BlNumber n)
{
//outstring (to_string (n) );
std::ostringstream oss;
oss << std::setprecision (16) << n;
outstring (oss.str () );
}
void BlFile::outinteger (BlInteger n)
{
outstring (to_string (n) );
}
void BlFile::outlinenumber (BlLineNumber l)
{
std::ostringstream oss;
oss << std::setw (7) << l;
outstring (oss.str () );
}
#endif
BlFile & operator << (BlFile & bf, const std::string & str)
{
TRACEFUNC (tr, "operator << (BlFile &, const string &)");
bf.outstring (str);
return bf;
}
BlFile & operator << (BlFile & bf, char c)
{
bf.outchar (c);
return bf;
}
BlFile & operator << (BlFile & bf, BlNumber n)
{
//bf.outnumber (n);
std::ostringstream oss;
oss << std::setprecision (16) << n;
bf.outstring (oss.str () );
return bf;
}
BlFile & operator << (BlFile & bf, BlInteger n)
{
//bf.outinteger (n);
bf.outstring (to_string (n) );
return bf;
}
BlFile & operator << (BlFile & bf, BlLineNumber l)
{
//bf.outlinenumber (l);
std::ostringstream oss;
oss << std::setw (7) << l;
bf.outstring (oss.str () );
return bf;
}
BlFile & operator << (BlFile & bf, unsigned short n)
{
bf.outstring (to_string (n) );
return bf;
}
void BlFile::putspaces (size_t n)
{
outstring (std::string (n, ' ') );
}
void BlFile::tab ()
{
outchar ('\t');
}
void BlFile::tab (size_t n)
{
// Provisional
outstring (std::string (n, ' ') );
}
void BlFile::endline ()
{
outchar ('\n');
}
void BlFile::put (size_t)
{ throw ErrFileMode; }
void BlFile::get (size_t)
{ throw ErrFileMode; }
void BlFile::field_clear ()
{ throw ErrFileMode; }
void BlFile::field (const std::vector <field_element> &)
{ throw ErrFileMode; }
void BlFile::field_append (const std::vector <field_element> &)
{ throw ErrFileMode; }
// assign doesn't throw because we call it for all open files,
// those that are no random files or does nor have the var in
// their fields just ignore it.
bool BlFile::assign (const std::string &, const Dimension &,
const std::string &, Align)
{ return false; }
bool BlFile::assign_mid (const std::string &, const Dimension &,
const std::string &, size_t, std::string::size_type)
{ return false; }
size_t BlFile::getwidth () const
{ throw ErrFileMode; }
void BlFile::movecharforward ()
{ throw ErrFileMode; }
void BlFile::movecharforward (size_t)
{ throw ErrFileMode; }
void BlFile::movecharback ()
{ throw ErrFileMode; }
void BlFile::movecharback (size_t)
{ throw ErrFileMode; }
void BlFile::movecharup ()
{ throw ErrFileMode; }
void BlFile::movecharup (size_t)
{ throw ErrFileMode; }
void BlFile::movechardown ()
{ throw ErrFileMode; }
void BlFile::movechardown (size_t)
{ throw ErrFileMode; }
void BlFile::showcursor ()
{ throw ErrFileMode; }
void BlFile::hidecursor ()
{ throw ErrFileMode; }
std::string BlFile::getkey ()
{ throw ErrFileMode; }
std::string BlFile::inkey ()
{ throw ErrFileMode; }
std::string BlFile::read (size_t)
{ throw ErrFileMode; }
void BlFile::gotoxy (int, int)
{ throw ErrFileMode; }
void BlFile::setcolor (int)
{ throw ErrFileMode; }
int BlFile::getcolor ()
{ throw ErrFileMode; }
void BlFile::setbackground (int)
{ throw ErrFileMode; }
int BlFile::getbackground ()
{ throw ErrFileMode; }
void BlFile::cls ()
{ throw ErrFileMode; }
std::string BlFile::copychr (BlChar, BlChar)
{ throw ErrFileMode; }
int BlFile::pos ()
{ throw ErrFileMode; }
int BlFile::vpos ()
{ throw ErrFileMode; }
void BlFile::tag ()
{ throw ErrFileMode; }
void BlFile::tagoff ()
{ /* Ignored */ }
bool BlFile::istagactive ()
{ return false; }
void BlFile::inverse (bool)
{ throw ErrFileMode; }
bool BlFile::getinverse ()
{ throw ErrFileMode; }
void BlFile::bright (bool)
{ throw ErrFileMode; }
bool BlFile::getbright ()
{ throw ErrFileMode; }
void BlFile::setwidth (size_t )
{ }
void BlFile::setmargin (size_t )
{ }
BlInteger BlFile::lof ()
{ throw ErrFileMode; }
bool BlFile::poll ()
{
return false;
}
void BlFile::scroll (int)
{ throw ErrFileMode; }
//***********************************************
// BlFileOut
//***********************************************
BlFileOut::BlFileOut () : BlFile (Output)
{ }
BlFileOut::BlFileOut (OpenMode mode) : BlFile (mode)
{ }
void BlFileOut::flush ()
{
ofs () << std::flush;
}
void BlFileOut::outstring (const std::string & str)
{
ofs () << str;
}
void BlFileOut::outchar (char c)
{
ofs () << c;
}
#if 0
void BlFileOut::outnumber (BlNumber n)
{
ofs () << n;
}
void BlFileOut::outinteger (BlInteger n)
{
ofs () << n;
}
void BlFileOut::outlinenumber (BlLineNumber l)
{
ofs () << std::setw (7) << l;
}
#endif
//***********************************************
// BlFileOutString
//***********************************************
BlFile * newBlFileOutString ()
{
return new BlFileOutString;
}
BlFileOutString::BlFileOutString ()
{ }
std::string BlFileOutString::str ()
{
return oss.str ();
}
std::ostream & BlFileOutString::ofs ()
{
return oss;
}
//***********************************************
// BlFileOutput
//***********************************************
class BlFileOutput : public BlFileOut {
public:
BlFileOutput (std::ostream & os);
bool isfile () const { return true; }
private:
std::ostream & ofs ();
std::ostream & os;
};
class BlFileRegular : public BlFileOut {
public:
BlFileRegular (const std::string & name, OpenMode mode);
bool isfile () const { return true; }
void getline (std::string & str, bool endline= true);
bool eof ();
void flush ();
virtual std::string getkey ();
virtual std::string inkey ();
std::string read (size_t n);
BlInteger lof ();
private:
std::ostream & ofs ();
std::fstream fs;
};
BlFile * newBlFileOutput (std::ostream & os)
{
return new BlFileOutput (os);
}
BlFileOutput::BlFileOutput (std::ostream & os) :
os (os)
{
}
std::ostream & BlFileOutput::ofs ()
{
return os;
}
//***********************************************
// BlFileRegular
//***********************************************
BlFile * newBlFileRegular (const std::string & name, OpenMode mode)
{
return new BlFileRegular (name, mode);
}
BlFileRegular::BlFileRegular (const std::string & name, OpenMode nmode) :
BlFileOut (nmode)
{
TRACEFUNC (tr, "BlFileRegular::BlFileRegular");
using std::ios;
ios::openmode mode= ios::in;
switch (nmode & ~ Binary)
{
case Input:
mode= ios::in; break;
case Output:
mode= ios::out; break;
case Append:
//mode= ios::out | ios::ate; break;
mode= ios::out | ios::app; break;
default:
if (showdebuginfo () )
cerr << "Unexpected mode value" << endl;
TRMESSAGE (tr, std::string ("Invalid mode ") +
util::to_string (nmode) );
throw ErrBlassicInternal;
}
if (nmode & Binary)
mode|= ios::binary;
fs.open (name.c_str (), mode);
if (! fs.is_open () )
{
if (showdebuginfo () )
cerr << "open (" << name << ", " << mode <<
") failed: " << strerror (errno) <<
endl;
throw ErrFileNotFound;
}
}
bool BlFileRegular::eof ()
{
int c= fs.get ();
if (! fs || c == EOF)
return true;
fs.unget ();
return false;
}
void BlFileRegular::flush ()
{
fs << std::flush;
}
void BlFileRegular::getline (std::string & str, bool)
{
std::getline (fs, str);
if (! fs)
{
if (fs.eof () )
throw ErrPastEof;
else
throw ErrFileRead;
}
}
std::string BlFileRegular::getkey ()
{
return read (1);
}
std::string BlFileRegular::inkey ()
{
int c= fs.get ();
if (! fs || c == EOF)
{
fs.clear (); // Allow further reads.
return std::string ();
}
return std::string (1, static_cast <char> (c) );
}
std::string BlFileRegular::read (size_t n)
{
util::auto_buffer <char> buf (n);
fs.read (buf, n);
if (! fs)
{
if (fs.eof () )
throw ErrPastEof;
else
throw ErrFileRead;
}
return std::string (buf, n);
}
std::ostream & BlFileRegular::ofs ()
{
return fs;
}
BlInteger BlFileRegular::lof ()
{
if (getmode () & Input)
return lengthoffileread (fs);
else
return lengthoffilewrite (fs);
}
//***********************************************
// BlFileRandom
//***********************************************
class BlFileRandom : public BlFile {
public:
BlFileRandom (const std::string & name, size_t record_len);
bool isfile () const { return true; }
bool eof ();
virtual size_t loc ();
void put (size_t pos);
void get (size_t pos);
void field_clear ();
void field (const std::vector <field_element> & elem);
void field_append (const std::vector <field_element> & elem);
virtual bool assign (const std::string & name, const Dimension & dim,
const std::string & value, Align align);
virtual bool assign_mid (const std::string & name,
const Dimension & dim,
const std::string & value,
size_t inipos, std::string::size_type len);
struct field_chunk {
std::string name;
Dimension dim;
size_t pos;
size_t size;
inline void getvar (char * buf) const;
};
typedef std::vector <field_chunk> vchunk;
BlInteger lof ();
private:
std::fstream fs;
size_t len;
size_t len_assigned;
bool used;
size_t actual;
//auto_array buf;
util::auto_buffer <char> buf;
vchunk chunk;
};
BlFile * newBlFileRandom (const std::string & name, size_t record_len)
{
return new BlFileRandom (name, record_len);
}
inline void BlFileRandom::field_chunk::getvar (char * buf) const
{
if (dim.empty () )
assignvarstring (name, std::string (buf + pos, size) );
else
assigndimstring (name, dim, std::string (buf + pos, size) );
}
BlFileRandom::BlFileRandom (const std::string & name, size_t record_len) :
BlFile (Random),
len (record_len),
len_assigned (0),
used (false),
actual (0),
buf (record_len)
{
using std::ios;
const ios::openmode iobin (ios::in | ios::out | ios::binary);
fs.open (name.c_str (), iobin);
if (! fs.is_open () )
{
// This can be necessary or not depending of the compiler
// to create the file if not exist. We test it, anyway.
if (errno == ENOENT)
{
fs.clear ();
fs.open (name.c_str (), ios::out | ios::binary);
if (fs.is_open () )
{
fs.close ();
fs.open (name.c_str (), iobin);
}
}
if (! fs.is_open () )
{
if (showdebuginfo () )
cerr << "open " << name << " failed: " <<
strerror (errno) << endl;
throw ErrFileNotFound;
}
}
std::fill_n (buf.begin (), len, '\0');
}
bool BlFileRandom::eof ()
{
fs.clear ();
fs.seekg (actual * len);
if (! fs)
{
if (fs.eof () )
return true;
throw ErrFileRead;
}
char testchar;
fs.read (& testchar, 1);
if (! fs)
{
if (fs.eof () )
return true;
throw ErrFileRead;
}
return fs.gcount () != 1;
}
size_t BlFileRandom::loc ()
{
return used ? actual + 1 : size_t (0);
}
void BlFileRandom::put (size_t pos)
{
used= true;
if (pos != 0)
{
actual= pos - 1;
fs.seekp (actual * len);
}
fs.write (buf, len);
++actual;
}
namespace {
class GetVar {
public:
GetVar (char * buf) : buf (buf) { }
void operator () (const BlFileRandom::field_chunk & chunk)
{
chunk.getvar (buf);
}
private:
char * buf;
};
} // namespace
void BlFileRandom::get (size_t pos)
{
using std::string;
used= true;
if (pos != 0)
actual= pos - 1;
fs.clear ();
fs.seekg (actual * len);
fs.read (buf, len);
std::streamsize r= fs.gcount ();
if (r < std::streamsize (len) )
std::fill_n (buf.begin () + r, len - r, ' ');
std::for_each (chunk.begin (), chunk.end (), GetVar (buf) );
++actual;
}
namespace {
class MakeChunk {
public:
MakeChunk (size_t len, size_t & pos) :
len (len),
pos (pos)
{ }
BlFileRandom::field_chunk operator ()
(const BlFile::field_element & elem)
{
size_t size= elem.size;
BlFileRandom::field_chunk fc;
fc.name= elem.name;
fc.dim= elem.dim;
fc.pos= pos;
fc.size= size;
pos+= size;
if (pos > len)
throw ErrFieldOverflow;
return fc;
}
size_t getpos () const { return pos; }
private:
const size_t len;
size_t & pos;
};
} // namespace
void BlFileRandom::field_clear ()
{
chunk.clear ();
len_assigned= 0;
}
void BlFileRandom::field_append (const std::vector <field_element> & elem)
{
TRACEFUNC (tr, "BlFileRandom::field_append");
// Create the field chunks.
//MakeChunk maker (len, len_assigned);
std::transform (elem.begin (), elem.end (),
std::back_inserter (chunk),
MakeChunk (len, len_assigned) );
// Check the assigned mark.
TRMESSAGE (tr, std::string ("len_assigned= ") +
util::to_string (len_assigned) );
// Assign initial values to the field variables (filled with
// zeroes if the file is opened and not touched).
// Do it for all fields, not only the added now.
std::for_each (chunk.begin (), chunk.end (), GetVar (buf) );
}
void BlFileRandom::field (const std::vector <field_element> & elem)
{
field_clear ();
field_append (elem);
}
namespace {
class field_var_is {
public:
field_var_is (const std::string & name, const Dimension & dim) :
name (name), dim (dim)
{ }
bool operator () (const BlFileRandom::field_chunk & chunk)
{
return chunk.name == name && chunk.dim == dim;
}
private:
const std::string & name;
const Dimension & dim;
};
} // namespace
bool BlFileRandom::assign (const std::string & name, const Dimension & dim,
const std::string & value, Align align)
{
vchunk::iterator pe= std::find_if (chunk.begin (), chunk.end (),
field_var_is (name, dim) );
if (pe == chunk.end () )
return false;
if (pe->size == 0)
return true;
char * init= buf + pe->pos;
std::string str;
// Changed the behaviour: now does the same as gwbasic.
#if 0
std::string::size_type l= value.size ();
if (align == AlignLeft)
{
if (l < pe->size)
str= value + std::string (pe->size - l, ' ');
else
str= value.substr (0, pe->size);
}
else
{
if (l < pe->size)
str= std::string (pe->size - l, ' ') + value;
else
str= value.substr (l - pe->size);
}
#else
if (align == AlignLeft)
str= util::stringlset (value, pe->size);
else
str= util::stringrset (value, pe->size);
#endif
ASSERT (str.size () == pe->size);
#if 0
std::copy (str.begin (), str.end (), init);
#else
str.copy (init, pe->size);
#endif
// Now also assign to the standalone var, so that the
// value assiged can be checked.
if (dim.empty () )
assignvarstring (name, str);
else
assigndimstring (name, dim, str);
return true;
}
bool BlFileRandom::assign_mid (const std::string & name,
const Dimension & dim,
const std::string & value,
size_t inipos, std::string::size_type len)
{
vchunk::iterator pe= std::find_if (chunk.begin (), chunk.end (),
field_var_is (name, dim) );
if (pe == chunk.end () )
return false;
const size_t size= pe->size;
if (size == 0)
return true;
if (inipos >= size)
return true;
char * const init= buf + pe->pos;
char * const initmid= init + inipos;
size_t l= size - inipos;
if (len > l)
len= l;
std::string str= value.substr (0, len);
if (str.size () < len)
str+= std::string (len - str.size (), ' ');
str.copy (initmid, str.size () );
// Now also assign to the standalone var, so that the
// value assiged can be checked.
if (dim.empty () )
assignvarstring (name, std::string (init, size) );
else
assigndimstring (name, dim, std::string (init, size) );
return true;
}
BlInteger BlFileRandom::lof ()
{
return lengthoffileread (fs);
}
} // namespace file
} // namespace blassic
// Fin de file.cpp
Jump to Line
Something went wrong with that request. Please try again.