diff --git a/INSTALL b/INSTALL index 6e90e07..007e939 100644 --- a/INSTALL +++ b/INSTALL @@ -1,7 +1,7 @@ Installation Instructions ************************* -Copyright (C) 1994-1996, 1999-2002, 2004-2012 Free Software Foundation, +Copyright (C) 1994-1996, 1999-2002, 2004-2013 Free Software Foundation, Inc. Copying and distribution of this file, with or without modification, diff --git a/build.sh b/build.sh index 112c721..59c3dcf 100755 --- a/build.sh +++ b/build.sh @@ -4,7 +4,7 @@ PREFIX=`cat Makefile | grep '^prefix =' | awk '{print $3}'` case $1 in '') echo '-- building...' - make -j3 + make -j5 echo '-- installing...' make uninstall 1>/dev/null make install 1>/dev/null @@ -15,7 +15,7 @@ case $1 in fi;; 'clean') echo '-- cleaning...' - make -j3 clean;; + make -j5 clean;; *) echo 'error: unknown action' 1>&2 exit 1;; diff --git a/latan/Exceptions.cpp b/latan/Exceptions.cpp index eab74ef..dd518ae 100644 --- a/latan/Exceptions.cpp +++ b/latan/Exceptions.cpp @@ -2,7 +2,7 @@ #include #ifndef ERR_PREF -#define ERR_PREF "[" + Env::Name + " v" + Env::Version + "] " +#define ERR_PREF "[" + Env::name + " v" + Env::version + "] " #endif #ifndef ERR_SUFF #define ERR_SUFF " (" + loc + ")" @@ -24,7 +24,7 @@ CONST_EXC(Range,Logic("range error: "+msg,loc)) // runtime errors CONST_EXC(Runtime,runtime_error(ERR_PREF+msg+ERR_SUFF)) CONST_EXC(Compilation,Runtime("compilation error: "+msg,loc)) -CONST_EXC(IO,Runtime("IO error: "+msg,loc)) +CONST_EXC(Io,Runtime("IO error: "+msg,loc)) CONST_EXC(Parsing,Runtime(msg,loc)) CONST_EXC(Syntax,Runtime("syntax error: "+msg,loc)) diff --git a/latan/Exceptions.hpp b/latan/Exceptions.hpp index c2bd9fb..190de94 100644 --- a/latan/Exceptions.hpp +++ b/latan/Exceptions.hpp @@ -28,7 +28,7 @@ namespace Exceptions // runtime errors DECL_EXC(Runtime,std::runtime_error); DECL_EXC(Compilation,Runtime); - DECL_EXC(IO,Runtime); + DECL_EXC(Io,Runtime); DECL_EXC(Parsing,Runtime); DECL_EXC(Syntax,Runtime); } diff --git a/latan/Global.cpp b/latan/Global.cpp index 0086eb6..af6bfdc 100644 --- a/latan/Global.cpp +++ b/latan/Global.cpp @@ -4,6 +4,6 @@ using namespace std; using namespace Latan; -const string Env::FullName = PACKAGE_STRING; -const string Env::Name = PACKAGE_NAME; -const string Env::Version = PACKAGE_VERSION; +const string Env::fullName = PACKAGE_STRING; +const string Env::name = PACKAGE_NAME; +const string Env::version = PACKAGE_VERSION; diff --git a/latan/Global.hpp b/latan/Global.hpp index 8befca6..b3e6047 100644 --- a/latan/Global.hpp +++ b/latan/Global.hpp @@ -19,9 +19,9 @@ LATAN_BEGIN_CPPDECL // Environment namespace Env { - extern const std::string FullName; - extern const std::string Name; - extern const std::string Version; + extern const std::string fullName; + extern const std::string name; + extern const std::string version; } // string conversions diff --git a/latan/IO.cpp b/latan/IO.cpp deleted file mode 100644 index d401996..0000000 --- a/latan/IO.cpp +++ /dev/null @@ -1,162 +0,0 @@ -#include -#include - -using namespace std; -using namespace Latan; - -// ASCII data format Bison/Flex parser declaration -int _IOASCII_parse(ASCIIParserState* state); - -/****************************************************************************** - * File implementation * - ******************************************************************************/ -// constructors //////////////////////////////////////////////////////////////// -File::File(void) -: name(""), mode(FileMode::Null), data() -{} - -File::File(const string init_name, const FileMode::Type init_mode) -: name(init_name), mode(init_mode), data() -{} - -// destructor ////////////////////////////////////////////////////////////////// -File::~File(void) -{} - -// access ////////////////////////////////////////////////////////////////////// -string File::Name(void) const -{ - return name; -} - -FileMode::Type File::Mode(void) const -{ - return mode; -} - -// Internal functions ////////////////////////////////////////////////////////// -void File::DeleteData(void) -{ - IODataTable::iterator i; - - for (i=data.begin();i!=data.end();++i) - { - delete i->second; - } - data.clear(); -} - -/****************************************************************************** - * ASCIIParserState implementation * - ******************************************************************************/ -// constructor ///////////////////////////////////////////////////////////////// -ASCIIParserState::ASCIIParserState(istream* pt_istream, string* pt_name,\ - IODataTable* pt_data) -: ParserState(pt_istream, pt_name, pt_data) -{ - init_scanner(); -} - -// destructor ////////////////////////////////////////////////////////////////// -ASCIIParserState::~ASCIIParserState(void) -{ - destroy_scanner(); -} - -/****************************************************************************** - * ASCIIFile implementation * - ******************************************************************************/ -// constructor ///////////////////////////////////////////////////////////////// -ASCIIFile::ASCIIFile(void) -: File(), file_stream(), is_parsed(false), state(NULL) -{} - -ASCIIFile::ASCIIFile(const string in_name, const FileMode::Type in_mode) -{ - OpenASCII(in_name,in_mode); -} - -// destructor ////////////////////////////////////////////////////////////////// -ASCIIFile::~ASCIIFile(void) -{ - Clear(); -} - -// tests /////////////////////////////////////////////////////////////////////// -bool ASCIIFile::IsOpen() const -{ - return file_stream.is_open(); -} - -// IO ////////////////////////////////////////////////////////////////////////// -void ASCIIFile::Close(void) -{ - Clear(); -} - -void ASCIIFile::Open(const string new_name, const FileMode::Type new_mode) -{ - if (IsOpen()) - { - LATAN_ERROR(IO,"file already opened with name '"+name+"'"); - } - OpenASCII(new_name,new_mode); -} - -void ASCIIFile::Save(void) -{ - LATAN_ERROR(Implementation,"saving ASCII files not implemented yet"); -} - -void ASCIIFile::SaveAs(const string new_name __dumb) -{ - LATAN_ERROR(Implementation,"saving ASCII files not implemented yet"); -} - -// Internal functions ////////////////////////////////////////////////////////// -void ASCIIFile::Clear() -{ - DeleteData(); - CloseASCII(); -} - -void ASCIIFile::OpenASCII(const string new_name, const FileMode::Type new_mode) -{ - if (!IsOpen()) - { - name = new_name; - mode = new_mode; - is_parsed = false; - file_stream.open(name.c_str()); - if (mode & FileMode::Read) - { - state = new ASCIIParserState(&file_stream,&name,&data); - } - else - { - state = NULL; - } - } -} - -void ASCIIFile::CloseASCII(void) -{ - if (state) - { - delete state; - state = NULL; - } - if (IsOpen()) - { - file_stream.close(); - } - name = ""; - mode = FileMode::Null; - is_parsed = false; -} - -void ASCIIFile::Parse() -{ - _IOASCII_parse(state); - is_parsed = true; -} diff --git a/latan/IO.hpp b/latan/IO.hpp deleted file mode 100644 index b8ffb08..0000000 --- a/latan/IO.hpp +++ /dev/null @@ -1,154 +0,0 @@ -#ifndef LATAN_IO_HPP_ -#define LATAN_IO_HPP_ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -LATAN_BEGIN_CPPDECL - -/****************************************************************************** - * Generic datafile class * - ******************************************************************************/ -typedef std::map IODataTable; - -namespace FileMode -{ - typedef enum - { - Null = 0, - Write = 1 << 0, - Read = 1 << 1, - Append = 1 << 2 - } Type; -} - -class File -{ -public: - // constructors - File(void); - File(const std::string in_name, const FileMode::Type in_mode); - // destructor - virtual ~File(void); - // access - std::string Name(void) const; - FileMode::Type Mode(void) const; - // tests - virtual bool IsOpen(void) const = 0; - // IO - virtual void Close(void) = 0; - virtual void Open(const std::string new_name,\ - const FileMode::Type new_mode) = 0; - virtual void Save(void) = 0; - virtual void SaveAs(const std::string new_name) = 0; -protected: - // protected members - std::string name; - FileMode::Type mode; - IODataTable data; - // protected methods - void DeleteData(void); - template const IOObj& GetData(const std::string data_name); -}; - -// Template implementations -template -const IOObj& File::GetData(const std::string data_name) -{ - try - { - return dynamic_cast(*(data.at(data_name))); - } - catch (std::out_of_range& e) - { - LATAN_ERROR(Range,"no data with name '"+data_name+"'"); - } -} - -/****************************************************************************** - * ASCII datafile class * - ******************************************************************************/ -class ASCIIParserState: public ParserState -{ -public: - // constructor - explicit ASCIIParserState(std::istream* pt_stream, std::string* name,\ - IODataTable* pt_data); - // destructor - virtual ~ASCIIParserState(void); - // public members - std::stack dmat_buf; - std::stack double_buf; -private: - // allocation/deallocation functions defined in IOASCIILexer.lpp - void init_scanner(void); - void destroy_scanner(void); -}; - -class ASCIIFile: public File -{ -public: - // constructors - ASCIIFile(void); - ASCIIFile(const std::string in_name, const FileMode::Type in_mode); - // destructor - virtual ~ASCIIFile(void); - // access - template const IOObj& Read(const std::string name); - // tests - virtual bool IsOpen(void) const; - // IO - virtual void Close(void); - virtual void Open(const std::string new_name,\ - const FileMode::Type new_mode); - virtual void Save(void); - virtual void SaveAs(const std::string new_name); -private: - // private members - std::fstream file_stream; - bool is_parsed; - ASCIIParserState* state; - // private methods - void Clear(void); - void OpenASCII(const std::string in_name, const FileMode::Type in_mode); - void CloseASCII(void); - void Parse(void); -}; - -// Template implementations -template -const IOObj& ASCIIFile::Read(const std::string data_name) -{ - if ((mode & FileMode::Read)&&(IsOpen())) - { - if (!is_parsed) - { - Parse(); - } - - return GetData(data_name); - } - else - { - if (IsOpen()) - { - LATAN_ERROR(IO,"file '"+name+"' is not opened in read mode"); - } - else - { - LATAN_ERROR(IO,"file not opened"); - } - } -} - -LATAN_END_CPPDECL - -#endif diff --git a/latan/IOObject.cpp b/latan/IOObject.cpp deleted file mode 100644 index 0958398..0000000 --- a/latan/IOObject.cpp +++ /dev/null @@ -1,12 +0,0 @@ -#include -#include - -using namespace Latan; - -IOObject::~IOObject(void) -{} - -IOTypes::Type IOObject::IOType(void) -{ - return IOTypes::NoType; -} diff --git a/latan/IOObject.hpp b/latan/IOObject.hpp deleted file mode 100644 index bfd9a7e..0000000 --- a/latan/IOObject.hpp +++ /dev/null @@ -1,25 +0,0 @@ -#ifndef LATAN_IOOBJECT_HPP_ -#define LATAN_IOOBJECT_HPP_ - -#include - -LATAN_BEGIN_CPPDECL - -// Abstract base for IO objects -class IOObject -{ -public: - enum IOType - { - noType = 0, - dMat = 1, - sample = 2 - }; -public: - virtual ~IOObject(void) = 0; - virtual IOType getType(void) = 0; -}; - -LATAN_END_CPPDECL - -#endif diff --git a/latan/Io.cpp b/latan/Io.cpp new file mode 100644 index 0000000..7bc7d1f --- /dev/null +++ b/latan/Io.cpp @@ -0,0 +1,168 @@ +#include +#include + +using namespace std; +using namespace Latan; + +// ASCII data format Bison/Flex parser declaration +int _ioAscii_parse(AsciiParserState* state); + +/****************************************************************************** + * File implementation * + ******************************************************************************/ +// constructors //////////////////////////////////////////////////////////////// +File::File(void) +: name_("") +, mode_(FileMode::null) +, data_() +{} + +File::File(const string name, const unsigned int mode) +: name_(name) +, mode_(mode) +, data_() +{} + +// destructor ////////////////////////////////////////////////////////////////// +File::~File(void) +{} + +// access ////////////////////////////////////////////////////////////////////// +string File::getName(void) const +{ + return name_; +} + +unsigned int File::getMode(void) const +{ + return mode_; +} + +// internal functions ////////////////////////////////////////////////////////// +void File::deleteData(void) +{ + IoDataTable::iterator i; + + for (i=data_.begin();i!=data_.end();++i) + { + delete i->second; + } + data_.clear(); +} + +/****************************************************************************** + * AsciiParserState implementation * + ******************************************************************************/ +// constructor ///////////////////////////////////////////////////////////////// +AsciiParserState::AsciiParserState(istream* stream, string* name, + IoDataTable* data) +: ParserState(stream, name, data) +{ + initScanner(); +} + +// destructor ////////////////////////////////////////////////////////////////// +AsciiParserState::~AsciiParserState(void) +{ + destroyScanner(); +} + +/****************************************************************************** + * AsciiFile implementation * + ******************************************************************************/ +// constructor ///////////////////////////////////////////////////////////////// +AsciiFile::AsciiFile(void) +: File(), fileStream_() +, isParsed_(false) +, state_(NULL) +{} + +AsciiFile::AsciiFile(const string name, const unsigned int mode) +{ + openAscii(name, mode); +} + +// destructor ////////////////////////////////////////////////////////////////// +AsciiFile::~AsciiFile(void) +{ + clear(); +} + +// tests /////////////////////////////////////////////////////////////////////// +bool AsciiFile::isOpen() const +{ + return fileStream_.is_open(); +} + +// IO ////////////////////////////////////////////////////////////////////////// +void AsciiFile::close(void) +{ + clear(); +} + +void AsciiFile::open(const string name, const unsigned int mode) +{ + if (isOpen()) + { + LATAN_ERROR(Io, "file already opened with name '" + name_ + "'"); + } + openAscii(name, mode); +} + +void AsciiFile::save(void) +{ + LATAN_ERROR(Implementation, "saving Ascii files not implemented yet"); +} + +void AsciiFile::saveAs(const string name __dumb) +{ + LATAN_ERROR(Implementation, "saving Ascii files not implemented yet"); +} + +// internal functions ////////////////////////////////////////////////////////// +void AsciiFile::clear() +{ + deleteData(); + closeAscii(); +} + +void AsciiFile::openAscii(const string name, const unsigned int mode) +{ + if (!isOpen()) + { + name_ = name; + mode_ = mode; + isParsed_ = false; + fileStream_.open(name_.c_str()); + if (mode_ & FileMode::read) + { + state_ = new AsciiParserState(&fileStream_, &name_, &data_); + } + else + { + state_ = NULL; + } + } +} + +void AsciiFile::closeAscii(void) +{ + if (state_) + { + delete state_; + state_ = NULL; + } + if (isOpen()) + { + fileStream_.close(); + } + name_ = ""; + mode_ = FileMode::null; + isParsed_ = false; +} + +void AsciiFile::parse() +{ + _ioAscii_parse(state_); + isParsed_ = true; +} diff --git a/latan/Io.hpp b/latan/Io.hpp new file mode 100644 index 0000000..ed0d7af --- /dev/null +++ b/latan/Io.hpp @@ -0,0 +1,154 @@ +#ifndef LATAN_IO_HPP_ +#define LATAN_IO_HPP_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +LATAN_BEGIN_CPPDECL + +/****************************************************************************** + * Generic datafile class * + ******************************************************************************/ +typedef std::map IoDataTable; + +class File +{ +public: + class FileMode + { + public: + enum + { + null = 0, + write = 1 << 0, + read = 1 << 1, + append = 1 << 2 + }; + }; +public: + // constructors + File(void); + File(const std::string name, const unsigned int mode); + // destructor + virtual ~File(void); + // access + std::string getName(void) const; + unsigned int getMode(void) const; + // tests + virtual bool isOpen(void) const = 0; + // Io + virtual void close(void) = 0; + virtual void open(const std::string name, const unsigned int mode) = 0; + virtual void save(void) = 0; + virtual void saveAs(const std::string name) = 0; +protected: + // data access + void deleteData(void); + template + const IoObj& getData(const std::string dataName); +protected: + std::string name_; + unsigned int mode_; + IoDataTable data_; +}; + +// Template implementations +template +const IoObj& File::getData(const std::string dataName) +{ + if (data_.find(dataName) != data_.end()) + { + return dynamic_cast(*(data_[dataName])); + } + else + { + LATAN_ERROR(Range, "no data with name '" + dataName + "'"); + } +} + +/****************************************************************************** + * ASCII datafile class * + ******************************************************************************/ +class AsciiParserState: public ParserState +{ +public: + // constructor + explicit AsciiParserState(std::istream* stream, std::string* name,\ + IoDataTable* data); + // destructor + virtual ~AsciiParserState(void); + // public members + std::stack dMatBuf; + std::stack doubleBuf; +private: + // allocation/deallocation functions defined in IoAsciiLexer.lpp + virtual void initScanner(void); + virtual void destroyScanner(void); +}; + +class AsciiFile: public File +{ +public: + // constructors + AsciiFile(void); + AsciiFile(const std::string name, const unsigned int mode); + // destructor + virtual ~AsciiFile(void); + // access + template + const IoObj& read(const std::string name); + // tests + virtual bool isOpen(void) const; + // Io + virtual void close(void); + virtual void open(const std::string name, const unsigned int mode); + virtual void save(void); + virtual void saveAs(const std::string name); +private: + void clear(void); + void openAscii(const std::string name, const unsigned int mode); + void closeAscii(void); + void parse(void); +private: + std::fstream fileStream_; + bool isParsed_; + AsciiParserState* state_; +}; + +// Template implementations +template +const IoObj& AsciiFile::read(const std::string dataName) +{ + if ((mode_ & FileMode::read)&&(isOpen())) + { + if (!isParsed_) + { + parse(); + } + + return getData(dataName); + } + else + { + if (isOpen()) + { + LATAN_ERROR(Io,"file '" + name_ + "' is not opened in read mode"); + } + else + { + LATAN_ERROR(Io,"file not opened"); + } + } +} + +LATAN_END_CPPDECL + +#endif diff --git a/latan/IOASCIILexer.lpp b/latan/IoAsciiLexer.lpp similarity index 92% rename from latan/IOASCIILexer.lpp rename to latan/IoAsciiLexer.lpp index 64bad16..ccda1f4 100644 --- a/latan/IOASCIILexer.lpp +++ b/latan/IoAsciiLexer.lpp @@ -1,5 +1,5 @@ %option reentrant -%option prefix="_IOASCII_" +%option prefix="_ioAscii_" %option bison-bridge %option bison-locations %option noyywrap @@ -16,7 +16,7 @@ using namespace std; using namespace Latan; - #define YY_EXTRA_TYPE ASCIIParserState* + #define YY_EXTRA_TYPE AsciiParserState* #define YY_USER_ACTION \ yylloc->first_line = yylloc->last_line = yylineno;\ yylloc->first_column = yylloc->last_column + 1;\ @@ -62,13 +62,13 @@ BLANK [ \t] %% -void ASCIIParserState::init_scanner() +void AsciiParserState::initScanner() { yylex_init(&scanner); yyset_extra(this, scanner); } -void ASCIIParserState::destroy_scanner() +void AsciiParserState::destroyScanner() { yylex_destroy(scanner); } diff --git a/latan/IOASCIIParser.ypp b/latan/IoAsciiParser.ypp similarity index 52% rename from latan/IOASCIIParser.ypp rename to latan/IoAsciiParser.ypp index 7a6026d..9966e12 100644 --- a/latan/IOASCIIParser.ypp +++ b/latan/IoAsciiParser.ypp @@ -11,11 +11,11 @@ %} %pure-parser -%name-prefix="_IOASCII_" +%name-prefix="_ioAscii_" %locations %defines %error-verbose -%parse-param { Latan::ASCIIParserState* state } +%parse-param { Latan::AsciiParserState* state } %initial-action {yylloc.last_column = 0;} %lex-param { void* scanner } @@ -36,15 +36,15 @@ %token OPEN %{ - int _IOASCII_lex(YYSTYPE* lvalp, YYLTYPE* llocp, void* scanner); + int _ioAscii_lex(YYSTYPE* lvalp, YYLTYPE* llocp, void* scanner); - void _IOASCII_error(YYLTYPE* locp, ASCIIParserState* state, const char* err) + void _ioAscii_error(YYLTYPE* locp, AsciiParserState* state, const char* err) { stringstream buf; - buf << *state->stream_name << ":" << locp->first_line << ":"\ + buf << *state->streamName << ":" << locp->first_line << ":"\ << locp->first_column << ": " << err; - LATAN_ERROR(Parsing,buf.str()); + LATAN_ERROR(Parsing, buf.str()); } #define scanner state->scanner @@ -60,26 +60,26 @@ datas: mat: OPEN MAT ID INT floats CLOSE MAT { - const int nrow = state->double_buf.size()/$INT, ncol = $INT; - (*state->data)[$ID] = new DMat(nrow,ncol); - DMat& M = static_cast(*((*state->data)[$ID])); + const int nRow = state->doubleBuf.size()/$INT, nCol = $INT; + (*state->data)[$ID] = new DMat(nRow,nCol); + DMat &M = static_cast(*((*state->data)[$ID])); int r,i,j; r = 0; - while (!state->double_buf.empty()) + while (!state->doubleBuf.empty()) { - j = r%ncol; - i = (r-j)/ncol; - M(i,j) = state->double_buf.top(); - state->double_buf.pop(); + j = r % nCol; + i = (r - j)/nCol; + M(i,j) = state->doubleBuf.top(); + state->doubleBuf.pop(); ++r; } } ; floats: - FLOAT floats {state->double_buf.push($1);} - | INT floats {state->double_buf.push(static_cast($1));} - | FLOAT {state->double_buf.push($1);} - | INT {state->double_buf.push(static_cast($1));} + FLOAT floats {state->doubleBuf.push($1);} + | INT floats {state->doubleBuf.push(static_cast($1));} + | FLOAT {state->doubleBuf.push($1);} + | INT {state->doubleBuf.push(static_cast($1));} ; diff --git a/latan/IoObject.hpp b/latan/IoObject.hpp new file mode 100644 index 0000000..c326d7f --- /dev/null +++ b/latan/IoObject.hpp @@ -0,0 +1,29 @@ +#ifndef LATAN_IOOBJECT_HPP_ +#define LATAN_IOOBJECT_HPP_ + +#include + +LATAN_BEGIN_CPPDECL + +// Abstract base for IO objects +class IoObject +{ +public: + class IoType + { + public: + enum + { + noType = 0, + dMat = 1, + sample = 2 + }; + }; +public: + virtual ~IoObject(void) = 0; + virtual unsigned int getType(void) = 0; +}; + +LATAN_END_CPPDECL + +#endif diff --git a/latan/Makefile.am b/latan/Makefile.am index 146bdc3..94999bb 100644 --- a/latan/Makefile.am +++ b/latan/Makefile.am @@ -20,7 +20,7 @@ AM_YFLAGS = -d include eigen_files.mk nobase_dist_pkginclude_HEADERS = $(eigen_files) -BUILT_SOURCES = IOASCIIParser.hpp MathParser.hpp +BUILT_SOURCES = IoAsciiParser.hpp MathParser.hpp lib_LTLIBRARIES = liblatan.la @@ -28,9 +28,9 @@ liblatan_la_SOURCES = \ Exceptions.cpp \ Global.cpp \ includes.hpp \ - IO.cpp \ - IOASCIIParser.ypp \ - IOASCIILexer.lpp \ + Io.cpp \ + IoAsciiParser.ypp \ + IoAsciiLexer.lpp \ Mat.cpp \ MathCompiler.cpp \ MathParser.ypp \ @@ -40,8 +40,8 @@ liblatan_la_SOURCES = \ liblatan_ladir = $(pkgincludedir) liblatan_la_HEADERS = \ Global.hpp \ - IO.hpp \ - IOObject.hpp \ + Io.hpp \ + IoObject.hpp \ Mat.hpp \ MathCompiler.hpp \ Sample.hpp diff --git a/latan/Mat.cpp b/latan/Mat.cpp index a8c7911..b9fc121 100644 --- a/latan/Mat.cpp +++ b/latan/Mat.cpp @@ -16,11 +16,11 @@ DMat::DMat(const DMat& M) : DMatBase(M) {} -DMat::DMat(unsigned int nrow, unsigned int ncol) -: DMatBase(nrow,ncol) +DMat::DMat(const unsigned int nRow, const unsigned int nCol) +: DMatBase(nRow,nCol) {} -IOObject::IOType DMat::getType(void) +unsigned int DMat::getType(void) { - return dMat; + return IoType::dMat; } diff --git a/latan/Mat.hpp b/latan/Mat.hpp index ebadd8e..f788ce4 100644 --- a/latan/Mat.hpp +++ b/latan/Mat.hpp @@ -13,15 +13,15 @@ typedef Eigen::MatrixXcd CMatBase; typedef Eigen::VectorXd DVecBase; typedef Eigen::VectorXcd CVecBase; -class DMat: public DMatBase, public IOObject +class DMat: public DMatBase, public IoObject { public: // constructors DMat(void); DMat(const DMat& M); - DMat(unsigned int nrow, unsigned int ncol); + DMat(const unsigned int nRow, const unsigned int nCol); // IO - virtual IOType getType(void); + virtual unsigned int getType(void); }; LATAN_END_CPPDECL diff --git a/latan/MathCompiler.cpp b/latan/MathCompiler.cpp index 884fdd6..7431a78 100644 --- a/latan/MathCompiler.cpp +++ b/latan/MathCompiler.cpp @@ -5,26 +5,29 @@ using namespace std; using namespace Latan; // Math Bison/Flex parser declaration -int _Math_parse(MathParserState* state); +int _math_parse(MathParserState* state); /****************************************************************************** * MathNode implementation * ******************************************************************************/ // constructor ///////////////////////////////////////////////////////////////// -MathNode::MathNode(const string& init_str, NodeType::Type init_type) -: str(init_str), type(init_type) +MathNode::MathNode(const string &name, const unsigned int type) +: name_(name) +, type_(type) {} -MathNode::MathNode(const std::string& init_str, NodeType::Type init_type,\ - const unsigned int narg, ...) -: str(init_str), type(init_type), arg(narg) +MathNode::MathNode(const std::string &name, const unsigned int type,\ + const unsigned int nArg, ...) +: name_(name) +, type_(type) +, arg_(nArg) { va_list va; - va_start(va,narg); - for (unsigned int i=0;i::iterator i; - for (i=arg.begin();i!=arg.end();++i) + for (i = arg_.begin(); i != arg_.end(); ++i) { delete *i; } } // access ////////////////////////////////////////////////////////////////////// -const string& MathNode::String(void) const +const string &MathNode::getName(void) const { - return str; + return name_; } -NodeType::Type MathNode::Type(void) const +unsigned int MathNode::getType(void) const { - return type; + return type_; } -unsigned int MathNode::NArg(void) const +unsigned int MathNode::getNArg(void) const { - return static_cast(arg.size()); + return static_cast(arg_.size()); } // operator //////////////////////////////////////////////////////////////////// -const MathNode& MathNode::operator[](const unsigned int i) const +const MathNode &MathNode::operator[](const unsigned int i) const { - return *arg[i]; + return *arg_[i]; } /****************************************************************************** * MathParserState implementation * ******************************************************************************/ // constructor ///////////////////////////////////////////////////////////////// -MathParserState::MathParserState(std::istream* pt_stream, std::string* pt_name,\ - MathNode** pt_data) -: ParserState(pt_stream,pt_name,pt_data) +MathParserState::MathParserState(std::istream *stream, std::string *name, + MathNode **data) +: ParserState(stream, name, data) { - init_scanner(); + initScanner(); } // destructor ////////////////////////////////////////////////////////////////// MathParserState::~MathParserState(void) { - destroy_scanner(); + destroyScanner(); } /****************************************************************************** @@ -88,97 +91,95 @@ MathParserState::~MathParserState(void) Instruction::~Instruction(void) {} -void Instruction::Print(std::ostream &out) const +ostream &Latan::operator<<(ostream& out, const Instruction& ins) { - out << CODE_MOD << "" << CODE_MOD << "ABSTRACT INSTRUCTION!"; -} - -ostream& Latan::operator<<(ostream& out, const Instruction& ins) -{ - ins.Print(out); + ins.print(out); return out; } -Push::Push(const double& init_cst) -: type(Constant), cst(init_cst), vname("") +Push::Push(const double val) +: type_(ArgType::Constant) +, val_(val) +, name_("") {} -Push::Push(const string& init_vname) -: type(Variable), cst(0.0), vname(init_vname) +Push::Push(const string &name) +: type_(ArgType::Variable) +, val_(0.0) +, name_(name) {} -void Push::operator()(std::stack &dstack, VarTable &vtable) +void Push::operator()(std::stack &dStack, VarTable &vTable) { - if (type == Constant) + if (type_ == ArgType::Constant) { - dstack.push(cst); + dStack.push(val_); } else { - dstack.push(vtable[vname]); + dStack.push(vTable[name_]); } } -void Push::Print(std::ostream &out) const +void Push::print(std::ostream &out) const { out << CODE_MOD << "push"; - if (type == Constant) + if (type_ == ArgType::Constant) { - out << CODE_MOD << cst; + out << CODE_MOD << val_; } else { - out << CODE_MOD << vname; + out << CODE_MOD << name_; } } -Pop::Pop(const string& init_vname) -: vname(init_vname) +Pop::Pop(const string &name) +: name_(name) {} -void Pop::operator()(std::stack &dstack, VarTable &vtable) +void Pop::operator()(std::stack &dStack, VarTable &vTable) { - vtable[vname] = dstack.top(); - dstack.pop(); + vTable[name_] = dStack.top(); + dStack.pop(); } -void Pop::Print(std::ostream &out) const +void Pop::print(std::ostream &out) const { - out << CODE_MOD << "pop" << CODE_MOD << vname; + out << CODE_MOD << "pop" << CODE_MOD << name_; } -#define DEF_OP(name,narg,exp,code_name)\ -void name::operator()(stack& dstack, VarTable& vtable __dumb)\ +#define DEF_OP(name, nArg, exp, insName)\ +void name::operator()(stack &dStack, VarTable &vTable __dumb)\ {\ - double x[narg];\ - for (int i=0;i(0) +: vector(0) {} -ostream& Latan::operator<<(ostream& out,const VirtualProgram& prog) +ostream &Latan::operator<<(ostream &out, const VirtualProgram &prog) { - for (unsigned int i=0;i"), state(NULL), root(NULL), out(), status(0) +: code_(NULL) +, codeName_("") +, state_(NULL) +, root_(NULL) +, out_() +, status_(Status::None) {} -MathCompiler::MathCompiler(const std::string& code_str) +MathCompiler::MathCompiler(const std::string &code) { - Init(code_str); + init(code); } // destructor ////////////////////////////////////////////////////////////////// MathCompiler::~MathCompiler(void) { - Reset(); + reset(); } // public methods ////////////////////////////////////////////////////////////// -void MathCompiler::Init(const std::string &code_str) +void MathCompiler::init(const std::string &code) { - if (status) + if (status_) { - Reset(); + reset(); } - code = new stringstream(code_str); - code_name = ""; - state = new MathParserState(code,&code_name,&root); - status |= Initialised; + code_ = new stringstream(code); + codeName_ = ""; + state_ = new MathParserState(code_, &codeName_, &root_); + status_ |= Status::Initialised; } const VirtualProgram& MathCompiler::operator()(void) { - if (!(status & Parsed)) + if (!(status_ & Status::Parsed)) { - Parse(); + parse(); } - if (!(status & Compiled)) + if (!(status_ & Status::Compiled)) { - Compile(*root); + compile(*root_); } - return out; + return out_; } // private methods ///////////////////////////////////////////////////////////// -void MathCompiler::Parse(void) +void MathCompiler::parse(void) { - _Math_parse(state); - status |= Parsed; - status -= status & Compiled; + _math_parse(state_); + status_ |= Status::Parsed; + status_ -= status_ & Status::Compiled; } -#define IFOP(name,narg) if ((N.String() == name)&&(N.NArg() == narg)) -#define ELIFOP(name,narg) else IFOP(name,narg) +#define IFOP(name, nArg) if ((n.getName() == (name))&&(n.getNArg() == nArg)) +#define ELIFOP(name, nArg) else IFOP(name, nArg) #define ELSE else -void MathCompiler::Compile(const MathNode& N) +void MathCompiler::compile(const MathNode& n) { - switch (N.Type()) + switch (n.getType()) { - case NodeType::Constant: - out.push_back(new Push(ato(N.String()))); + case MathNode::Type::Constant: + out_.push_back(new Push(ato(n.getName()))); break; - case NodeType::Variable: - out.push_back(new Push(N.String())); + case MathNode::Type::Variable: + out_.push_back(new Push(n.getName())); break; - case NodeType::Operator: - for (unsigned int i=0;i arg; + std::string name_; + unsigned int type_; + std::vector arg_; }; -class MathParserState: public ParserState +class MathParserState: public ParserState { public: // constructor - explicit MathParserState(std::istream* pt_stream, std::string* name,\ - MathNode** pt_data); + explicit MathParserState(std::istream *stream, std::string *name, + MathNode **data); // destructor virtual ~MathParserState(void); private: - // allocation/deallocation functions defined in IOASCIILexer.lpp - void init_scanner(void); - void destroy_scanner(void); + // allocation/deallocation functions defined in MathLexer.lpp + virtual void initScanner(void); + virtual void destroyScanner(void); }; /****************************************************************************** * Virtual machine code classes * ******************************************************************************/ -typedef std::map VarTable; +typedef std::map VarTable; // Abstract base class Instruction @@ -73,39 +74,50 @@ class Instruction public: virtual ~Instruction(); // instruction execution - virtual void operator()(std::stack& dstack, VarTable& vtable) = 0; - friend std::ostream& operator<<(std::ostream& out, const Instruction& ins); + virtual void operator()(std::stack &dStack, VarTable &vTable) = 0; + friend std::ostream& operator<<(std::ostream &out, const Instruction &ins); private: - virtual void Print(std::ostream& out) const; + virtual void print(std::ostream &out) const = 0; }; // push and pop class Push: public Instruction { +private: + class ArgType + { + public: + enum + { + Constant = 0, + Variable = 1 + }; + }; public: //constructors - explicit Push(const double& init_cst); - explicit Push(const std::string& init_vname); + explicit Push(const double val); + explicit Push(const std::string &name); // instruction execution - virtual void operator()(std::stack& dstack, VarTable& vtable); + virtual void operator()(std::stack &dStack, VarTable &vTable); private: - typedef enum {Constant = 0, Variable = 1} ArgType; - ArgType type; - double cst; - std::string vname; - virtual void Print(std::ostream& out) const; + virtual void print(std::ostream& out) const; +private: + unsigned int type_; + double val_; + std::string name_; }; class Pop: public Instruction { public: //constructor - explicit Pop(const std::string& init_vname); + explicit Pop(const std::string &name); // instruction execution - virtual void operator()(std::stack& dstack, VarTable& vtable); + virtual void operator()(std::stack &dStack, VarTable &vTable); private: - std::string vname; - virtual void Print(std::ostream& out) const; + virtual void print(std::ostream& out) const; +private: + std::string name_; }; // Float operations @@ -113,9 +125,9 @@ private: class name: public Instruction\ {\ public:\ - virtual void operator()(std::stack& dstack, VarTable& vtable);\ + virtual void operator()(std::stack &dStack, VarTable &vTable);\ private:\ - virtual void Print(std::ostream& out) const;\ + virtual void print(std::ostream &out) const;\ } DECL_OP(Neg); @@ -125,12 +137,12 @@ DECL_OP(Mul); DECL_OP(Div); DECL_OP(Pow); -class VirtualProgram: public std::vector +class VirtualProgram: public std::vector { public: VirtualProgram(void); - friend std::ostream& operator<<(std::ostream& out, \ - const VirtualProgram& prog); + friend std::ostream &operator<<(std::ostream &out, + const VirtualProgram &program); }; /****************************************************************************** @@ -138,34 +150,38 @@ public: ******************************************************************************/ class MathCompiler { +private: + class Status + { + public: + enum + { + None = 0, + Initialised = 1 << 0, + Parsed = 1 << 1, + Compiled = 1 << 2 + }; + }; public: // constructors MathCompiler(void); - MathCompiler(const std::string& code_str); + MathCompiler(const std::string &code); // destructor ~MathCompiler(void); // initialization - void Init(const std::string& code_str); - const VirtualProgram& operator()(void); + void init(const std::string &code); + const VirtualProgram &operator()(void); private: - // status flags - enum - { - Initialised = 1 << 0, - Parsed = 1 << 1, - Compiled = 1 << 2 - }; - // private members - std::istream* code; - std::string code_name; - MathParserState* state; - MathNode* root; - VirtualProgram out; - unsigned int status; - // private methods - void Parse(void); - void Compile(const MathNode& N); - void Reset(void); + void parse(void); + void compile(const MathNode& node); + void reset(void); +private: + std::istream *code_; + std::string codeName_; + MathParserState *state_; + MathNode *root_; + VirtualProgram out_; + unsigned int status_; }; LATAN_END_CPPDECL diff --git a/latan/MathLexer.lpp b/latan/MathLexer.lpp index c6a829f..0f6f49c 100644 --- a/latan/MathLexer.lpp +++ b/latan/MathLexer.lpp @@ -1,5 +1,5 @@ %option reentrant -%option prefix="_Math_" +%option prefix="_math_" %option bison-bridge %option bison-locations %option noyywrap @@ -63,13 +63,13 @@ BLANK [ \t] %% -void MathParserState::init_scanner() +void MathParserState::initScanner() { yylex_init(&scanner); yyset_extra(this, scanner); } -void MathParserState::destroy_scanner() +void MathParserState::destroyScanner() { yylex_destroy(scanner); } diff --git a/latan/MathParser.ypp b/latan/MathParser.ypp index 2879369..3b55026 100644 --- a/latan/MathParser.ypp +++ b/latan/MathParser.ypp @@ -10,7 +10,7 @@ %} %pure-parser -%name-prefix="_Math_" +%name-prefix="_math_" %locations %defines %error-verbose @@ -38,13 +38,13 @@ %type expr %{ - int _Math_lex(YYSTYPE* lvalp, YYLTYPE* llocp, void* scanner); + int _math_lex(YYSTYPE* lvalp, YYLTYPE* llocp, void* scanner); - void _Math_error(YYLTYPE* locp, MathParserState* state, const char* err) + void _math_error(YYLTYPE* locp, MathParserState* state, const char* err) { stringstream buf; - buf << *state->stream_name << ":" << locp->first_line << ":"\ + buf << *state->streamName << ":" << locp->first_line << ":"\ << locp->first_column << ": " << err; LATAN_ERROR(Parsing,buf.str()); } @@ -56,17 +56,25 @@ program: /* empty string */ - | expr {*state->data = $1;} + | expr {*state->data = $1;} ; expr: - FLOAT {$$ = new MathNode($FLOAT,NodeType::Constant);} - | ID {$$ = new MathNode($ID,NodeType::Variable);} - | '-' expr %prec UMINUS {$$ = new MathNode("-",NodeType::Operator,1,$2);} - | expr '+' expr {$$ = new MathNode("+",NodeType::Operator,2,$1,$3);} - | expr '-' expr {$$ = new MathNode("-",NodeType::Operator,2,$1,$3);} - | expr '*' expr {$$ = new MathNode("*",NodeType::Operator,2,$1,$3);} - | expr '/' expr {$$ = new MathNode("/",NodeType::Operator,2,$1,$3);} - | expr '^' expr {$$ = new MathNode("^",NodeType::Operator,2,$1,$3);} - | '(' expr ')' {$$ = $2;} + FLOAT + {$$ = new MathNode($FLOAT, MathNode::Type::Constant);} + | ID + {$$ = new MathNode($ID,MathNode::Type::Variable);} + | '-' expr %prec UMINUS + {$$ = new MathNode("-", MathNode::Type::Operator, 1,$2);} + | expr '+' expr + {$$ = new MathNode("+", MathNode::Type::Operator, 2, $1, $3);} + | expr '-' expr + {$$ = new MathNode("-", MathNode::Type::Operator, 2, $1, $3);} + | expr '*' expr + {$$ = new MathNode("*", MathNode::Type::Operator, 2, $1, $3);} + | expr '/' expr + {$$ = new MathNode("/", MathNode::Type::Operator, 2, $1, $3);} + | expr '^' expr + {$$ = new MathNode("^", MathNode::Type::Operator, 2, $1, $3);} + | '(' expr ')' {$$ = $2;} ; diff --git a/latan/ParserState.hpp b/latan/ParserState.hpp index 8f903e9..a4e001f 100644 --- a/latan/ParserState.hpp +++ b/latan/ParserState.hpp @@ -12,22 +12,29 @@ class ParserState { public: // constructor - explicit ParserState(std::istream* pt_stream, std::string* pt_name,\ - DataObj* pt_data); + explicit ParserState(std::istream *streamPt, std::string *namePt, + DataObj *dataPt); // destructor virtual ~ParserState(void); - // public members +private: + // scanner allocation/deallocation + virtual void initScanner(void) = 0; + virtual void destroyScanner(void) = 0; +public: DataObj* data; void* scanner; std::istream* stream; - std::string* stream_name; + std::string* streamName; + }; template -ParserState::ParserState(std::istream* pt_stream,\ - std::string* pt_name, \ - DataObj* pt_data) -: data(pt_data), scanner(NULL), stream(pt_stream), stream_name(pt_name) +ParserState::ParserState(std::istream *streamPt, std::string *namePt, + DataObj *dataPt) +: data(dataPt) +, scanner(NULL) +, stream(streamPt) +, streamName(namePt) {} template diff --git a/latan/Sample.cpp b/latan/Sample.cpp index c6bc41d..9bf9680 100644 --- a/latan/Sample.cpp +++ b/latan/Sample.cpp @@ -3,28 +3,28 @@ using namespace Latan; -Sample::Sample(void) -: central(0,0), sample(static_cast(0)) +DSample::DSample(void) +: DSampleBase(static_cast(0)) {} -Sample::Sample(const unsigned int init_nsample, const unsigned int init_nrow,\ - const unsigned int init_ncol) -: central(init_nrow,init_ncol), sample(init_nsample) +DSample::DSample(const unsigned int nSample, const unsigned int nRow, + const unsigned int nCol) +: DSampleBase(static_cast(nSample + 1)) { - for (unsigned int s=0;s= 0) { - return sample(s); + return (*this)(s + 1); } else { - return central; + return (*this)(0); } } diff --git a/latan/Sample.hpp b/latan/Sample.hpp index fb6389a..0b456e5 100644 --- a/latan/Sample.hpp +++ b/latan/Sample.hpp @@ -8,25 +8,18 @@ LATAN_BEGIN_CPPDECL const int Central = -1; -class Sample +typedef Eigen::Array DSampleBase; + +class DSample: public DSampleBase { -private: - // type alias for disambiguation - typedef Eigen::Array ArrayType; - public: // Constructors/destructor - Sample(void); - Sample(const unsigned int init_nsample, const unsigned int init_nrow,\ - const unsigned int init_ncol); - ~Sample(void); + DSample(void); + DSample(const unsigned int nSample, const unsigned int nRow, + const unsigned int nCol); + ~DSample(void); // Operators DMat& operator()(const int s); - -private: - // type aliases - DMat central; - ArrayType sample; }; LATAN_END_CPPDECL