Move files to prepare for assimilation into core

diff --git a/source/base.cpp b/source/base.cpp
deleted file mode 100644 (file)
index 48de3ee..0000000
--- a/source/base.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-#include "base.h"
-#include "poll.h"
-
-using namespace std;
-
-namespace Msp {
-namespace IO {
-
-Base::Base():
-       mode(M_READ),
-       events(P_NONE),
-       eof_flag(false)
-{ }
-
-Base::~Base()
-{
-       signal_deleted.emit();
-}
-
-bool Base::getline(string &line)
-{
-       line.clear();
-
-       if(eof_flag)
-               return false;
-
-       while(1)
-       {
-               int c = get();
-               if(c==-1 || c=='\n')
-                       break;
-               line += c;
-       }
-
-       return !eof_flag || !line.empty();
-}
-
-int Base::get()
-{
-       char c;
-       if(do_read(&c, 1)==0)
-               return -1;
-       return static_cast<unsigned char>(c);
-}
-
-void Base::set_events(PollEvent e)
-{
-       events = e;
-       signal_events_changed.emit(events);
-}
-
-void Base::event(PollEvent ev)
-{
-       if(ev&P_INPUT)
-               signal_data_available.emit();
-
-       on_event(ev);
-}
-
-} // namespace IO
-} // namespace Msp

diff --git a/source/base.h b/source/base.h
deleted file mode 100644 (file)
index 774d034..0000000
--- a/source/base.h
+++ /dev/null
@@ -1,121 +0,0 @@
-#ifndef MSP_IO_BASE_H_
-#define MSP_IO_BASE_H_
-
-#include <sigc++/sigc++.h>
-#include "mode.h"
-#include "poll.h"
-#include "types.h"
-
-namespace Msp {
-namespace IO {
-
-/**
-Common interface for all I/O objects.
-
-A derived class must call set_events(P_NONE) before it is destroyed to avoid
-leaving stale pointers in an EventDispatcher.
-*/
-class Base
-{
-public:
-       /** Emitted when there is data available for reading.  If all data is not
-       read, the signal is emitted again immediately. */
-       sigc::signal<void> signal_data_available;
-
-       /** Emitted when there is no more data to be read. */
-       sigc::signal<void> signal_end_of_file;
-
-       /** Emitted when there is a nonlinearity in I/O (such as a file being
-       seeked) and any data buffered by upper layers needs to be flushed. */
-       sigc::signal<void> signal_flush_required;
-
-       /** Emitted when the I/O object has closed. */
-       sigc::signal<void> signal_closed;
-
-       /** Emitted when the mask of interesting events changes.  Mainly for use by
-       EventDispatcher. */
-       sigc::signal<void, PollEvent> signal_events_changed;
-
-       /** Emitted when the object is deleted.  Mainly for use by
-       EventDispatcher. */
-       sigc::signal<void> signal_deleted;
-
-protected:
-       Mode mode;
-       PollEvent events;
-       bool eof_flag;
-
-       Base();
-private:
-       Base(const Base &);
-       Base &operator=(const Base &);
-public:
-       virtual ~Base();
-
-       /** Sets blocking mode.  When blocking is enabled, most operations won't
-       return until they can make progress.  When blocking is disabled, these
-       operations may return immediately with a return code indicating that nothing
-       was done.
-
-       Blocking is enabled by default. */
-       virtual void set_block(bool) { }
-
-       /** Returns the current mode flags. */
-       Mode get_mode() const { return mode; }
-
-protected:
-       virtual unsigned do_write(const char *, unsigned) =0;
-       virtual unsigned do_read(char *, unsigned) =0;
-
-public:
-       /** Writes data from a buffer.  Subject to blocking.  Returns the number of
-       bytes written, which may be zero for a non-blockin operation. */
-       unsigned write(const char *b, unsigned c) { return do_write(b, c); }
-
-       /** Writes a string.  This is identical to calling
-       write(s.data(), s.size()). */
-       unsigned write(const std::string &s) { return do_write(s.data(), s.size()); }
-
-       /** Writes a single character.  This is identical to calling
-       write(&c, 1). */
-       virtual unsigned put(char c) { return do_write(&c, 1); }
-
-       /** Reads data into a buffer.  Subject to blocking.  Returns the number of
-       bytes read, which may be zero for a non-blocking operation. */
-       unsigned read(char *b, unsigned c) { return do_read(b, c); }
-
-       /** Reads characters up to the next linefeed or end-of-file.  The linefeed
-       is not included in the line.  Returns true if a line was successfully read,
-       false otherwise. */
-       virtual bool getline(std::string &);
-
-       /** Reads a single character.  Returns -1 if no character was available due
-       to end-of-file or non-blocking operation. */
-       virtual int get();
-
-       /** Returns the end-of-file flag. */
-       bool eof() const { return eof_flag; }
-
-protected:
-       void set_events(PollEvent);
-
-public:
-       /** Returns a mask of the currently interesting events.  Used by
-       EventDispatcher. */
-       PollEvent get_events() const { return events; }
-
-       /** Returns a handle for polling.  Should throw if the object does not have
-       an event handle. */
-       virtual Handle get_event_handle() =0;
-
-       /** Notifies the object of an event.  Used by EventDispatcher. */
-       void event(PollEvent);
-
-protected:
-       virtual void on_event(PollEvent) { }
-};
-
-} // namespace IO
-} // namespace Msp
-
-#endif

diff --git a/source/buffered.cpp b/source/buffered.cpp
deleted file mode 100644 (file)
index f53d2fc..0000000
--- a/source/buffered.cpp
+++ /dev/null
@@ -1,188 +0,0 @@
-#include <cstring>
-#include "buffered.h"
-#include "except.h"
-
-using namespace std;
-
-namespace Msp {
-namespace IO {
-
-Buffered::Buffered(Base &b, unsigned s):
-       below(b),
-       buf_size(s),
-       buf(new char[buf_size]),
-       begin(buf),
-       end(buf),
-       cur_op(M_NONE)
-{
-       mode = below.get_mode();
-       below.signal_flush_required.connect(sigc::mem_fun(this, &Buffered::flush));
-}
-
-Buffered::~Buffered()
-{
-       try
-       {
-               flush();
-       }
-       catch(...)
-       { }
-
-       delete[] buf;
-}
-
-void Buffered::flush()
-{
-       if(cur_op==M_WRITE)
-       {
-               unsigned used = end-begin;
-               if(used)
-               {
-                       unsigned len = below.write(begin, used);
-
-                       begin=end = buf;
-
-                       if(len<used)
-                               throw Exception("Couldn't flush all data");
-               }
-       }
-       else if(cur_op==M_READ)
-               begin=end = buf;
-}
-
-unsigned Buffered::do_write(const char *data, unsigned size)
-{
-       set_op(M_WRITE);
-
-       if(end+size<buf+buf_size)
-       {
-               // All data fits in buffer with whatever is already there
-               memcpy(end, data, size);
-               end += size;
-
-               return size;
-       }
-       else
-       {
-               // Clear the buffer to make more room
-               flush();
-
-               if(size<buf_size)
-               {
-                       // Put new data in the buffer to wait for more
-                       memcpy(end, data, size);
-                       end += size;
-
-                       return size;
-               }
-               else
-                       // New data still doesn't fit in the buffer, so write it directly
-                       return below.write(data, size);
-       }
-}
-
-unsigned Buffered::do_read(char *data, unsigned size)
-{
-       set_op(M_READ);
-
-       if(begin+size<=end)
-       {
-               // The request can be served from the buffer
-               memcpy(data, begin, size);
-               begin += size;
-
-               eof_flag = (below.eof() && begin==end);
-
-               return size;
-       }
-       else
-       {
-               // Give out whatever is in the buffer already
-               memcpy(data, begin, end-begin);
-               unsigned ret = end-begin;
-               begin=end = buf;
-
-               data += ret;
-               size -= ret;
-
-               if(size<buf_size)
-               {
-                       // Fill the buffer and serve the rest of the request from it
-                       unsigned len = below.read(end, buf+buf_size-end);
-                       end += len;
-
-                       len = min(static_cast<unsigned>(end-begin), size);
-                       memcpy(data, begin, len);
-                       begin += len;
-                       ret += len;
-               }
-               else
-                       // Read the rest directly from the underlying object
-                       ret += below.read(data, size);
-
-               eof_flag = (below.eof() && begin==end);
-
-               return ret;
-       }
-}
-
-unsigned Buffered::put(char c)
-{
-       set_op(M_WRITE);
-
-       if(end<buf+buf_size)
-       {
-               *end++ = c;
-               return 1;
-       }
-       else
-               return do_write(&c, 1);
-}
-
-bool Buffered::getline(std::string &line)
-{
-       set_op(M_READ);
-
-       for(char *i=begin; i!=end; ++i)
-               if(*i=='\n')
-               {
-                       line.assign(begin, i-begin);
-                       begin = i+1;
-                       return true;
-               }
-
-       return Base::getline(line);
-}
-
-int Buffered::get()
-{
-       set_op(M_READ);
-
-       if(begin<end)
-               return static_cast<unsigned char>(*begin++);
-
-       char c;
-       if(do_read(&c, 1)==0)
-               return -1;
-       return static_cast<unsigned char>(c);
-}
-
-void Buffered::set_op(Mode op)
-{
-       if(op!=cur_op)
-               flush();
-       cur_op = op;
-}
-
-unsigned Buffered::get_current_size() const
-{
-       return end-begin;
-}
-
-Handle Buffered::get_event_handle()
-{
-       throw Exception("Buffered doesn't support events");
-}
-
-} // namespace IO
-} // namespace Msp

diff --git a/source/buffered.h b/source/buffered.h
deleted file mode 100644 (file)
index 36d2a11..0000000
--- a/source/buffered.h
+++ /dev/null
@@ -1,46 +0,0 @@
-#ifndef MSP_IO_BUFFERED_H_
-#define MSP_IO_BUFFERED_H_
-
-#include "base.h"
-
-namespace Msp {
-namespace IO {
-
-class Buffered: public Base
-{
-private:
-       Base &below;
-       unsigned buf_size;
-       char *buf;
-       char *begin;
-       char *end;
-       Mode cur_op;
-
-public:
-       Buffered(Base &, unsigned =8192);
-       ~Buffered();
-
-       void flush();
-
-protected:
-       unsigned do_write(const char *, unsigned);
-       unsigned do_read(char *, unsigned);
-public:
-       unsigned put(char);
-
-       bool getline(std::string &);
-       int get();
-
-private:
-       void set_op(Mode);
-public:
-       Mode get_current_op() const { return cur_op; }
-       unsigned get_current_size() const;
-
-       virtual Handle get_event_handle();
-};
-
-} // namespace IO
-} // namespace Msp
-
-#endif

diff --git a/source/console.cpp b/source/console.cpp
deleted file mode 100644 (file)
index 9db7737..0000000
--- a/source/console.cpp
+++ /dev/null
@@ -1,187 +0,0 @@
-#ifndef WIN32
-#include <errno.h>
-#include <fcntl.h>
-#include <termios.h>
-#include <sys/ioctl.h>
-#endif
-#include <msp/core/except.h>
-#include "console.h"
-
-namespace {
-
-#ifndef WIN32
-termios orig_attr;
-#endif
-
-} // namespace
-
-namespace Msp {
-namespace IO {
-
-Console::Console(unsigned n)
-{
-       if(n>2)
-               throw InvalidParameterValue("Invalid parameter for Console::Console");
-
-       mode = (n==0 ? M_READ : M_WRITE);
-
-#ifdef WIN32
-       switch(n)
-       {
-       case 0: handle = GetStdHandle(STD_INPUT_HANDLE); break;
-       case 1: handle = GetStdHandle(STD_OUTPUT_HANDLE); break;
-       case 2: handle = GetStdHandle(STD_ERROR_HANDLE); break;
-       }
-#else
-       handle = n;
-
-       if(handle==0)
-               tcgetattr(handle, &orig_attr);
-#endif
-
-       if(n==0)
-               set_events(P_INPUT);
-}
-
-Console::~Console()
-{
-#ifndef WIN32
-       if(handle==0)
-               tcsetattr(handle, TCSADRAIN, &orig_attr);
-#endif
-}
-
-void Console::set_block(bool b)
-{
-#ifdef WIN32
-       // XXX Dunno how to do this in win32
-       (void)b;
-#else
-       int flags = fcntl(0, F_GETFL);
-       flags = (flags&~O_NONBLOCK) | (b?0:O_NONBLOCK);
-       fcntl(0, F_SETFL, flags);
-#endif
-}
-
-void Console::set_local_echo(bool e)
-{
-       if(!(mode&M_READ))
-               throw InvalidState("Local echo can only be set on input console");
-
-#ifdef WIN32
-       DWORD m;
-       GetConsoleMode(handle, &m);
-       SetConsoleMode(handle, (m&~ENABLE_ECHO_INPUT) | (e?ENABLE_ECHO_INPUT:0));
-#else
-       termios t;
-       tcgetattr(0, &t);
-       t.c_lflag = (t.c_lflag&~ECHO) | (e?ECHO:0);
-       tcsetattr(0, TCSADRAIN, &t);
-#endif
-}
-
-void Console::set_line_buffer(bool l)
-{
-       if(!(mode&M_READ))
-               throw InvalidState("Line buffering can only be set on input console");
-
-#ifdef WIN32
-       DWORD m;
-       GetConsoleMode(handle, &m);
-       SetConsoleMode(handle, (m&~ENABLE_LINE_INPUT) | (l?ENABLE_LINE_INPUT:0));
-#else
-       // XXX ICANON does more than just set line buffering, may need a bit more thought
-       termios t;
-       tcgetattr(0, &t);
-       t.c_lflag = (t.c_lflag&~ICANON) | (l?ICANON:0);
-       tcsetattr(0, TCSADRAIN, &t);
-#endif
-}
-
-void Console::get_size(unsigned &rows, unsigned &cols)
-{
-       if(!(mode&M_WRITE))
-               throw InvalidState("Size can only be queried from an output console");
-
-#ifdef WIN32
-       // XXX Figure out how to do this
-       rows = 24;
-       cols = 80;
-#else
-       struct winsize wsz;
-       ioctl(handle, TIOCGWINSZ, &wsz);
-       rows = wsz.ws_row;
-       cols = wsz.ws_col;
-#endif
-}
-
-unsigned Console::do_write(const char *buf, unsigned len)
-{
-       if(!(mode&M_WRITE))
-               throw InvalidState("Console is not writable");
-
-#ifdef WIN32
-       DWORD ret;
-       if(!WriteFile(handle, buf, len, &ret, 0))
-               throw SystemError("Writing to console failed", GetLastError());
-#else
-       int ret = ::write(handle, buf, len);
-       if(ret==-1)
-               throw SystemError("Writing to console failed", errno);
-#endif
-
-       return ret;
-}
-
-unsigned Console::do_read(char *buf, unsigned len)
-{
-       if(!(mode&M_READ))
-               throw InvalidState("Console is not readable");
-
-#ifdef WIN32
-       DWORD ret;
-       if(!ReadFile(handle, buf, len, &ret, 0))
-               throw SystemError("Reading from console failed", GetLastError());
-#else
-       int ret = ::read(handle, buf, len);
-       if(ret==-1)
-       {
-               if(errno==EAGAIN)
-                       return 0;
-               else
-                       throw SystemError("Reading from console failed", errno);
-       }
-       else if(ret==0)
-               eof_flag = true;
-#endif
-
-       return ret;
-}
-
-Handle Console::get_event_handle()
-{
-       return 0;
-}
-
-Console &Console::instance(unsigned n)
-{
-       static Console in(0);
-       static Console out(1);
-       static Console err(2);
-
-       switch(n)
-       {
-       case 0: return in;
-       case 1: return out;
-       case 2: return err;
-       }
-
-       throw InvalidParameterValue("Unknown Console instance requested");
-}
-
-Console &cin = Console::instance(0);
-Console &cout = Console::instance(1);
-Console &cerr = Console::instance(2);
-
-} // namespace IO
-} // namespace Msp

diff --git a/source/console.h b/source/console.h
deleted file mode 100644 (file)
index 3c0bb71..0000000
--- a/source/console.h
+++ /dev/null
@@ -1,56 +0,0 @@
-#ifndef MSP_IO_CONSOLE_H_
-#define MSP_IO_CONSOLE_H_
-
-#include "base.h"
-
-namespace Msp {
-namespace IO {
-
-/**
-Provides access to standard input, output and error streams.  This class can't
-be instantiated directly - use one of the cin, cout and cerr references
-instead.
-*/
-class Console: public Base
-{
-private:
-       Handle handle;
-
-       Console(unsigned);
-public:
-       ~Console();
-
-       virtual void set_block(bool);
-       
-       /** If local echo is enabled, characters will appear on the console as they
-       are typed.  Can only be used on an input Console.  */
-       void set_local_echo(bool);
-
-       /** If line buffering is enabled, input will only be available when a
-       newline is encountered.  On some systems, this may also enable line editing.
-       Can only be used on an input Console.
-       */
-       void set_line_buffer(bool);
-
-       /** Retrieves the size of the Console.  Can only be used on an output
-       Console. */
-       void get_size(unsigned &rows, unsigned &cols);
-
-protected:
-       virtual unsigned do_write(const char *, unsigned);
-       virtual unsigned do_read(char *, unsigned);
-
-public:
-       virtual Handle get_event_handle();
-
-       static Console &instance(unsigned);
-};
-
-extern Console &cin;
-extern Console &cout;
-extern Console &cerr;
-
-} // namespace IO
-} // namespace Msp
-
-#endif

diff --git a/source/eventdispatcher.cpp b/source/eventdispatcher.cpp
deleted file mode 100644 (file)
index 06a594f..0000000
--- a/source/eventdispatcher.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-#include <msp/time/units.h>
-#include "base.h"
-#include "eventdispatcher.h"
-#include "poll.h"
-
-namespace Msp {
-namespace IO {
-
-EventDispatcher::EventDispatcher()
-{ }
-
-void EventDispatcher::add(Base &obj)
-{
-       SlotMap::iterator i = objects.find(&obj);
-       if(i==objects.end())
-       {
-               i = objects.insert(SlotMap::value_type(&obj, Slot(&obj))).first;
-               i->second.evch_conn = obj.signal_events_changed.connect(sigc::bind(sigc::mem_fun(this, &EventDispatcher::object_events_changed), &obj));
-               i->second.del_conn = obj.signal_deleted.connect(sigc::bind(sigc::mem_fun(this, &EventDispatcher::object_deleted), &obj));
-
-               if(obj.get_events())
-                       poller.set_object(obj, obj.get_events());
-       }
-}
-
-void EventDispatcher::remove(Base &obj)
-{
-       SlotMap::iterator i = objects.find(&obj);
-       if(i!=objects.end())
-       {
-               i->second.evch_conn.disconnect();
-               i->second.del_conn.disconnect();
-               objects.erase(i);
-
-               poller.set_object(obj, P_NONE);
-       }
-}
-
-void EventDispatcher::tick()
-{
-       if(objects.empty())
-               return;
-
-       if(poller.poll()>0)
-               dispatch();
-}
-
-void EventDispatcher::tick(const Time::TimeDelta &dt)
-{
-       if(objects.empty())
-               return;
-
-       if(poller.poll(dt)>0)
-               dispatch();
-}
-
-void EventDispatcher::object_events_changed(PollEvent ev, Base *obj)
-{
-       poller.set_object(*obj, ev);
-}
-
-void EventDispatcher::object_deleted(Base *obj)
-{
-       remove(*obj);
-}
-
-void EventDispatcher::dispatch()
-{
-       const Poller::SlotSeq &result = poller.get_result();
-       for(Poller::SlotSeq::const_iterator i=result.begin(); i!=result.end(); ++i)
-               i->object->event(i->events);
-}
-
-} // namespace IO
-} // namespace Msp

diff --git a/source/eventdispatcher.h b/source/eventdispatcher.h
deleted file mode 100644 (file)
index 7e89d47..0000000
--- a/source/eventdispatcher.h
+++ /dev/null
@@ -1,55 +0,0 @@
-#ifndef EVENTDISPATCHER_H_
-#define EVENTDISPATCHER_H_
-
-#include <sigc++/connection.h>
-#include <sigc++/trackable.h>
-#include "poll.h"
-
-namespace Msp {
-namespace IO {
-
-/**
-Put your I/O objects inside one of these to get signaled when something happens
-on some of them.
-*/
-class EventDispatcher: public sigc::trackable
-{
-private:
-       struct Slot
-       {
-               Base *obj;
-               sigc::connection evch_conn;
-               sigc::connection del_conn;
-
-               Slot(Base *o): obj(o) { }
-       };
-
-       typedef std::map<Base *, Slot> SlotMap;
-
-       Poller poller;
-       SlotMap objects;
-
-public:
-       EventDispatcher();
-
-       void add(Base &);
-       void remove(Base &);
-
-       /** Checks for and dispatches events.  If there are no events available,
-       blocks until there are. */
-       void tick();
-
-       /** Checks for and dispatches events.  If there are no events available,
-       waits at most the specified time before returning. */
-       void tick(const Time::TimeDelta &);
-
-private:
-       void object_events_changed(PollEvent, Base *);
-       void object_deleted(Base *);
-       void dispatch();
-};
-
-} // namespace IO
-} // namespace Msp
-
-#endif

diff --git a/source/except.h b/source/except.h
deleted file mode 100644 (file)
index 5770f64..0000000
--- a/source/except.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#ifndef MSP_IO_EXCEPT_H_
-#define MSP_IO_EXCEPT_H_
-
-#include <msp/core/except.h>
-
-namespace Msp {
-namespace IO {
-
-class FileNotFound: public Exception
-{
-public:
-       FileNotFound(const std::string &w_, const std::string &f): Exception(w_), filename(f) { }
-       const std::string &get_filename() { return filename; }
-       ~FileNotFound() throw() { }
-private:
-       std::string filename;
-};
-
-} // namespace IO
-} // namespace Msp
-
-#endif

diff --git a/source/file.cpp b/source/file.cpp
deleted file mode 100644 (file)
index 2990d5c..0000000
--- a/source/file.cpp
+++ /dev/null
@@ -1,242 +0,0 @@
-#ifndef WIN32
-#include <errno.h>
-#include <fcntl.h>
-#include <unistd.h>
-#endif
-#include <msp/strings/formatter.h>
-#include "except.h"
-#include "file.h"
-
-using namespace std;
-
-namespace Msp {
-namespace IO {
-
-File::File(const string &fn, Mode m, CreateMode cm)
-{
-       if(!(m&M_RDWR))
-               throw InvalidParameterValue("Invalid read/write mode");
-       if(cm&~(C_CREATE|C_TRUNCATE))
-               throw InvalidParameterValue("Invalid create mode");
-
-       mode = m;
-
-#ifdef WIN32
-       int flags = 0;
-       int create_flags = OPEN_EXISTING;
-
-       if(mode&M_READ)
-               flags |= GENERIC_READ;
-       else if(mode&M_WRITE)
-       {
-               flags |= GENERIC_WRITE;
-
-               switch(static_cast<int>(cm))
-               {
-               case C_NONE:     create_flags = OPEN_EXISTING; break;
-               case C_CREATE:   create_flags = OPEN_ALWAYS; break;
-               case C_TRUNCATE: create_flags = TRUNCATE_EXISTING; break;
-               case C_CREATE+C_TRUNCATE: create_flags = CREATE_ALWAYS; break;
-               }
-       }
-
-       handle = CreateFile(fn.c_str(), flags, 0, 0, create_flags, FILE_ATTRIBUTE_NORMAL, 0);
-       if(handle==INVALID_HANDLE_VALUE)
-       {
-               int err = GetLastError();
-               if(err==ERROR_FILE_NOT_FOUND)
-                       throw FileNotFound("Can't find file "+fn, fn);
-               else
-                       throw SystemError(format("Can't open file '%s'", fn), GetLastError());
-       }
-#else
-       int flags = 0;
-       switch(mode&M_RDWR)
-       {
-       case M_READ:  flags |= O_RDONLY; break;
-       case M_WRITE: flags |= O_WRONLY; break;
-       case M_RDWR:  flags |= O_RDWR; break;
-       default:;
-       }
-
-       if(mode&M_WRITE)
-       {
-               if(cm&C_CREATE)
-                       flags |= O_CREAT;
-               if(cm&C_TRUNCATE)
-                       flags |= O_TRUNC;
-       }
-       if(mode&M_APPEND)
-               flags |= O_APPEND;
-       if(mode&M_NONBLOCK)
-               flags |= O_NONBLOCK;
-
-       handle = ::open(fn.c_str(), flags, 0666);
-       if(handle==-1)
-       {
-               int err = errno;
-               if(err==ENOENT)
-                       throw FileNotFound("Can't find file "+fn, fn);
-               else
-                       throw SystemError(format("Can't open file '%s'", fn), err);
-       }
-#endif
-
-       set_events(P_INPUT);
-}
-
-File::~File()
-{
-       close();
-}
-
-void File::close()
-{
-       if(handle==MSP_IO_INVALID_HANDLE)
-               return;
-
-       set_events(P_NONE);
-
-       signal_flush_required.emit();
-
-#ifdef WIN32
-       CloseHandle(handle);
-#else
-       ::close(handle);
-#endif
-
-       handle = MSP_IO_INVALID_HANDLE;
-       signal_closed.emit();
-}
-
-void File::set_block(bool b)
-{
-       check_access(M_NONE);
-
-       mode = (mode&~M_NONBLOCK);
-       if(b)
-               mode = (mode|M_NONBLOCK);
-#ifndef WIN32
-       int flags = fcntl(handle, F_GETFD);
-       fcntl(handle, F_SETFL, (flags&O_NONBLOCK)|(b?0:O_NONBLOCK));
-#endif
-}
-
-unsigned File::do_write(const char *buf, unsigned size)
-{
-       check_access(M_WRITE);
-
-       if(size==0)
-               return 0;
-
-#ifdef WIN32
-       if(mode&M_APPEND)
-               seek(0, S_END);
-       DWORD ret;
-       if(WriteFile(handle, buf, size, &ret, 0)==0)
-               throw SystemError("Writing to file failed", GetLastError());
-#else
-       int ret = ::write(handle, buf, size);
-       if(ret==-1)
-       {
-               if(errno==EAGAIN)
-                       return 0;
-               else
-                       throw SystemError("Writing to file failed", errno);
-       }
-#endif
-
-       return ret;
-}
-
-unsigned File::do_read(char *buf, unsigned size)
-{
-       check_access(M_READ);
-
-       if(size==0)
-               return 0;
-
-#ifdef WIN32
-       DWORD ret;
-       if(ReadFile(handle, buf, size, &ret, 0)==0)
-               throw SystemError("Reading from file failed", GetLastError());
-#else
-       int ret = ::read(handle, buf, size);
-       if(ret==-1)
-       {
-               if(errno==EAGAIN)
-                       return 0;
-               else
-                       throw SystemError("Reading from file failed", errno);
-       }
-#endif
-
-       if(ret==0)
-       {
-               eof_flag = true;
-               signal_end_of_file.emit();
-       }
-
-       return ret;
-}
-
-void File::sync()
-{
-#ifndef WIN32
-       signal_flush_required.emit();
-
-       fsync(handle);
-#endif
-}
-
-int File::seek(int off, SeekType st)
-{
-       check_access(M_NONE);
-
-       signal_flush_required.emit();
-
-       int type = sys_seek_type(st);
-#ifdef WIN32
-       DWORD ret = SetFilePointer(handle, off, 0, type);
-       if(ret==INVALID_SET_FILE_POINTER)
-               throw SystemError("Seek failed", GetLastError());
-#else
-       int ret = lseek(handle, off, type);
-       if(ret==-1)
-               throw SystemError("Seek failed", errno);
-#endif
-
-       eof_flag = false;
-
-       return ret;
-}
-
-int File::tell() const
-{
-       check_access(M_NONE);
-
-#ifdef WIN32
-       DWORD ret = SetFilePointer(handle, 0, 0, FILE_CURRENT);
-       if(ret==INVALID_SET_FILE_POINTER)
-               throw SystemError("Tell failed", GetLastError());
-#else
-       int ret = lseek(handle, 0, SEEK_CUR);
-       if(ret==-1)
-               throw SystemError("Tell failed", errno);
-#endif
-
-       return ret;
-}
-
-void File::check_access(Mode m) const
-{
-       if(handle==MSP_IO_INVALID_HANDLE)
-               throw InvalidState("File is not open");
-       if(m==M_READ && !(mode&M_READ))
-               throw InvalidState("File is not readable");
-       if(m==M_WRITE && !(mode&M_WRITE))
-               throw InvalidState("File is not writable");
-}
-
-} // namespace IO
-} // namespace Msp

diff --git a/source/file.h b/source/file.h
deleted file mode 100644 (file)
index 05aaf95..0000000
--- a/source/file.h
+++ /dev/null
@@ -1,77 +0,0 @@
-#ifndef MSP_IO_FILE_H_
-#define MSP_IO_FILE_H_
-
-#include <string>
-#include "base.h"
-#include "buffered.h"
-#include "filtered.h"
-#include "seek.h"
-
-namespace Msp {
-namespace IO {
-
-/**
-A class for reading and writing files.
-
-Non-blocking mode is not supported on Win32.
-*/
-class File: public Base
-{
-public:
-       enum CreateMode
-       {
-               C_NONE = 0,
-               C_CREATE = 1,
-               C_TRUNCATE = 2
-       };
-
-private:
-       Handle handle;
-
-public:
-       /** Creates a new file object and opens it.  If the create flag is set and
-       write access is requested and the file does exist, it is created.  Otherwise
-       a missing file is an error. */
-       File(const std::string &, Mode = M_READ, CreateMode = CreateMode(C_CREATE+C_TRUNCATE));
-       virtual ~File();
-
-       /** Closes the file.  Any attempt to access the file after this will cause
-       an exception to be thrown. */
-       void close();
-
-       void set_block(bool);
-
-protected:
-       virtual unsigned do_write(const char *, unsigned);
-       virtual unsigned do_read(char *, unsigned);
-
-public:
-       virtual void sync();
-
-       /** Changes the read/write offset of the file.  Returns the new offset. */
-       virtual int seek(int, SeekType);
-       
-       /** Returns the current read/write offset of the file. */
-       virtual int tell() const;
-
-       virtual Handle get_event_handle() { return handle; }
-
-private:
-       void check_access(Mode) const;
-};
-
-inline File::CreateMode operator|(File::CreateMode m, File::CreateMode n)
-{ return File::CreateMode(static_cast<int>(m)|static_cast<int>(n)); }
-
-inline File::CreateMode operator&(File::CreateMode m, File::CreateMode n)
-{ return File::CreateMode(static_cast<int>(m)&static_cast<int>(n)); }
-
-inline File::CreateMode operator~(File::CreateMode m)
-{ return File::CreateMode(~static_cast<int>(m)); }
-
-typedef Filtered<File, Buffered> BufferedFile;
-
-} // namespace IO
-} // namespace Msp
-
-#endif

diff --git a/source/filtered.h b/source/filtered.h
deleted file mode 100644 (file)
index 0d323ec..0000000
--- a/source/filtered.h
+++ /dev/null
@@ -1,66 +0,0 @@
-#ifndef MSP_IO_FILTERED_H_
-#define MSP_IO_FILTERED_H_
-
-namespace Msp {
-namespace IO {
-
-template<typename B, typename F>
-class Filtered: public B
-{
-private:
-       struct Activator
-       {
-               Filtered &f;
-
-               Activator(Filtered &f_): f(f_) { f.active = true; }
-               ~Activator() { f.active = false; }
-       };
-
-       F filter;
-       bool active;
-
-public:
-       Filtered(): filter(*this), active(false) { }
-       ~Filtered() { active = true; }
-
-       template<typename A0>
-       Filtered(A0 a0): B(a0), filter(*this), active(false) { }
-
-       template<typename A0, typename A1>
-       Filtered(A0 a0, A1 a1): B(a0, a1), filter(*this), active(false) { }
-
-protected:
-       virtual unsigned do_write(const char *b, unsigned s)
-       {
-               if(!active)
-               {
-                       Activator a(*this);
-                       return filter.write(b, s);
-               }
-               else
-                       return B::do_write(b, s);
-       }
-
-       virtual unsigned do_read(char *b, unsigned s)
-       {
-               if(!active)
-               {
-                       Activator a(*this);
-                       return filter.read(b, s);
-               }
-               else
-                       return B::do_read(b, s);
-       }
-
-public:
-       virtual unsigned put(char c) { return filter.put(c); }
-       virtual bool getline(std::string &l) { return filter.getline(l); }
-       virtual int get() { return filter.get(); }
-
-       F &get_filter() { return filter; }
-};
-
-} // namespace IO
-} // namespace Msp
-
-#endif

diff --git a/source/io/base.cpp b/source/io/base.cpp
new file mode 100644 (file)
index 0000000..48de3ee
--- /dev/null
+++ b/source/io/base.cpp
@@ -0,0 +1,61 @@
+#include "base.h"
+#include "poll.h"
+
+using namespace std;
+
+namespace Msp {
+namespace IO {
+
+Base::Base():
+       mode(M_READ),
+       events(P_NONE),
+       eof_flag(false)
+{ }
+
+Base::~Base()
+{
+       signal_deleted.emit();
+}
+
+bool Base::getline(string &line)
+{
+       line.clear();
+
+       if(eof_flag)
+               return false;
+
+       while(1)
+       {
+               int c = get();
+               if(c==-1 || c=='\n')
+                       break;
+               line += c;
+       }
+
+       return !eof_flag || !line.empty();
+}
+
+int Base::get()
+{
+       char c;
+       if(do_read(&c, 1)==0)
+               return -1;
+       return static_cast<unsigned char>(c);
+}
+
+void Base::set_events(PollEvent e)
+{
+       events = e;
+       signal_events_changed.emit(events);
+}
+
+void Base::event(PollEvent ev)
+{
+       if(ev&P_INPUT)
+               signal_data_available.emit();
+
+       on_event(ev);
+}
+
+} // namespace IO
+} // namespace Msp

diff --git a/source/io/base.h b/source/io/base.h
new file mode 100644 (file)
index 0000000..774d034
--- /dev/null
+++ b/source/io/base.h
@@ -0,0 +1,121 @@
+#ifndef MSP_IO_BASE_H_
+#define MSP_IO_BASE_H_
+
+#include <sigc++/sigc++.h>
+#include "mode.h"
+#include "poll.h"
+#include "types.h"
+
+namespace Msp {
+namespace IO {
+
+/**
+Common interface for all I/O objects.
+
+A derived class must call set_events(P_NONE) before it is destroyed to avoid
+leaving stale pointers in an EventDispatcher.
+*/
+class Base
+{
+public:
+       /** Emitted when there is data available for reading.  If all data is not
+       read, the signal is emitted again immediately. */
+       sigc::signal<void> signal_data_available;
+
+       /** Emitted when there is no more data to be read. */
+       sigc::signal<void> signal_end_of_file;
+
+       /** Emitted when there is a nonlinearity in I/O (such as a file being
+       seeked) and any data buffered by upper layers needs to be flushed. */
+       sigc::signal<void> signal_flush_required;
+
+       /** Emitted when the I/O object has closed. */
+       sigc::signal<void> signal_closed;
+
+       /** Emitted when the mask of interesting events changes.  Mainly for use by
+       EventDispatcher. */
+       sigc::signal<void, PollEvent> signal_events_changed;
+
+       /** Emitted when the object is deleted.  Mainly for use by
+       EventDispatcher. */
+       sigc::signal<void> signal_deleted;
+
+protected:
+       Mode mode;
+       PollEvent events;
+       bool eof_flag;
+
+       Base();
+private:
+       Base(const Base &);
+       Base &operator=(const Base &);
+public:
+       virtual ~Base();
+
+       /** Sets blocking mode.  When blocking is enabled, most operations won't
+       return until they can make progress.  When blocking is disabled, these
+       operations may return immediately with a return code indicating that nothing
+       was done.
+
+       Blocking is enabled by default. */
+       virtual void set_block(bool) { }
+
+       /** Returns the current mode flags. */
+       Mode get_mode() const { return mode; }
+
+protected:
+       virtual unsigned do_write(const char *, unsigned) =0;
+       virtual unsigned do_read(char *, unsigned) =0;
+
+public:
+       /** Writes data from a buffer.  Subject to blocking.  Returns the number of
+       bytes written, which may be zero for a non-blockin operation. */
+       unsigned write(const char *b, unsigned c) { return do_write(b, c); }
+
+       /** Writes a string.  This is identical to calling
+       write(s.data(), s.size()). */
+       unsigned write(const std::string &s) { return do_write(s.data(), s.size()); }
+
+       /** Writes a single character.  This is identical to calling
+       write(&c, 1). */
+       virtual unsigned put(char c) { return do_write(&c, 1); }
+
+       /** Reads data into a buffer.  Subject to blocking.  Returns the number of
+       bytes read, which may be zero for a non-blocking operation. */
+       unsigned read(char *b, unsigned c) { return do_read(b, c); }
+
+       /** Reads characters up to the next linefeed or end-of-file.  The linefeed
+       is not included in the line.  Returns true if a line was successfully read,
+       false otherwise. */
+       virtual bool getline(std::string &);
+
+       /** Reads a single character.  Returns -1 if no character was available due
+       to end-of-file or non-blocking operation. */
+       virtual int get();
+
+       /** Returns the end-of-file flag. */
+       bool eof() const { return eof_flag; }
+
+protected:
+       void set_events(PollEvent);
+
+public:
+       /** Returns a mask of the currently interesting events.  Used by
+       EventDispatcher. */
+       PollEvent get_events() const { return events; }
+
+       /** Returns a handle for polling.  Should throw if the object does not have
+       an event handle. */
+       virtual Handle get_event_handle() =0;
+
+       /** Notifies the object of an event.  Used by EventDispatcher. */
+       void event(PollEvent);
+
+protected:
+       virtual void on_event(PollEvent) { }
+};
+
+} // namespace IO
+} // namespace Msp
+
+#endif

diff --git a/source/io/buffered.cpp b/source/io/buffered.cpp
new file mode 100644 (file)
index 0000000..f53d2fc
--- /dev/null
+++ b/source/io/buffered.cpp
@@ -0,0 +1,188 @@
+#include <cstring>
+#include "buffered.h"
+#include "except.h"
+
+using namespace std;
+
+namespace Msp {
+namespace IO {
+
+Buffered::Buffered(Base &b, unsigned s):
+       below(b),
+       buf_size(s),
+       buf(new char[buf_size]),
+       begin(buf),
+       end(buf),
+       cur_op(M_NONE)
+{
+       mode = below.get_mode();
+       below.signal_flush_required.connect(sigc::mem_fun(this, &Buffered::flush));
+}
+
+Buffered::~Buffered()
+{
+       try
+       {
+               flush();
+       }
+       catch(...)
+       { }
+
+       delete[] buf;
+}
+
+void Buffered::flush()
+{
+       if(cur_op==M_WRITE)
+       {
+               unsigned used = end-begin;
+               if(used)
+               {
+                       unsigned len = below.write(begin, used);
+
+                       begin=end = buf;
+
+                       if(len<used)
+                               throw Exception("Couldn't flush all data");
+               }
+       }
+       else if(cur_op==M_READ)
+               begin=end = buf;
+}
+
+unsigned Buffered::do_write(const char *data, unsigned size)
+{
+       set_op(M_WRITE);
+
+       if(end+size<buf+buf_size)
+       {
+               // All data fits in buffer with whatever is already there
+               memcpy(end, data, size);
+               end += size;
+
+               return size;
+       }
+       else
+       {
+               // Clear the buffer to make more room
+               flush();
+
+               if(size<buf_size)
+               {
+                       // Put new data in the buffer to wait for more
+                       memcpy(end, data, size);
+                       end += size;
+
+                       return size;
+               }
+               else
+                       // New data still doesn't fit in the buffer, so write it directly
+                       return below.write(data, size);
+       }
+}
+
+unsigned Buffered::do_read(char *data, unsigned size)
+{
+       set_op(M_READ);
+
+       if(begin+size<=end)
+       {
+               // The request can be served from the buffer
+               memcpy(data, begin, size);
+               begin += size;
+
+               eof_flag = (below.eof() && begin==end);
+
+               return size;
+       }
+       else
+       {
+               // Give out whatever is in the buffer already
+               memcpy(data, begin, end-begin);
+               unsigned ret = end-begin;
+               begin=end = buf;
+
+               data += ret;
+               size -= ret;
+
+               if(size<buf_size)
+               {
+                       // Fill the buffer and serve the rest of the request from it
+                       unsigned len = below.read(end, buf+buf_size-end);
+                       end += len;
+
+                       len = min(static_cast<unsigned>(end-begin), size);
+                       memcpy(data, begin, len);
+                       begin += len;
+                       ret += len;
+               }
+               else
+                       // Read the rest directly from the underlying object
+                       ret += below.read(data, size);
+
+               eof_flag = (below.eof() && begin==end);
+
+               return ret;
+       }
+}
+
+unsigned Buffered::put(char c)
+{
+       set_op(M_WRITE);
+
+       if(end<buf+buf_size)
+       {
+               *end++ = c;
+               return 1;
+       }
+       else
+               return do_write(&c, 1);
+}
+
+bool Buffered::getline(std::string &line)
+{
+       set_op(M_READ);
+
+       for(char *i=begin; i!=end; ++i)
+               if(*i=='\n')
+               {
+                       line.assign(begin, i-begin);
+                       begin = i+1;
+                       return true;
+               }
+
+       return Base::getline(line);
+}
+
+int Buffered::get()
+{
+       set_op(M_READ);
+
+       if(begin<end)
+               return static_cast<unsigned char>(*begin++);
+
+       char c;
+       if(do_read(&c, 1)==0)
+               return -1;
+       return static_cast<unsigned char>(c);
+}
+
+void Buffered::set_op(Mode op)
+{
+       if(op!=cur_op)
+               flush();
+       cur_op = op;
+}
+
+unsigned Buffered::get_current_size() const
+{
+       return end-begin;
+}
+
+Handle Buffered::get_event_handle()
+{
+       throw Exception("Buffered doesn't support events");
+}
+
+} // namespace IO
+} // namespace Msp

diff --git a/source/io/buffered.h b/source/io/buffered.h
new file mode 100644 (file)
index 0000000..36d2a11
--- /dev/null
+++ b/source/io/buffered.h
@@ -0,0 +1,46 @@
+#ifndef MSP_IO_BUFFERED_H_
+#define MSP_IO_BUFFERED_H_
+
+#include "base.h"
+
+namespace Msp {
+namespace IO {
+
+class Buffered: public Base
+{
+private:
+       Base &below;
+       unsigned buf_size;
+       char *buf;
+       char *begin;
+       char *end;
+       Mode cur_op;
+
+public:
+       Buffered(Base &, unsigned =8192);
+       ~Buffered();
+
+       void flush();
+
+protected:
+       unsigned do_write(const char *, unsigned);
+       unsigned do_read(char *, unsigned);
+public:
+       unsigned put(char);
+
+       bool getline(std::string &);
+       int get();
+
+private:
+       void set_op(Mode);
+public:
+       Mode get_current_op() const { return cur_op; }
+       unsigned get_current_size() const;
+
+       virtual Handle get_event_handle();
+};
+
+} // namespace IO
+} // namespace Msp
+
+#endif

diff --git a/source/io/console.cpp b/source/io/console.cpp
new file mode 100644 (file)
index 0000000..9db7737
--- /dev/null
+++ b/source/io/console.cpp
@@ -0,0 +1,187 @@
+#ifndef WIN32
+#include <errno.h>
+#include <fcntl.h>
+#include <termios.h>
+#include <sys/ioctl.h>
+#endif
+#include <msp/core/except.h>
+#include "console.h"
+
+namespace {
+
+#ifndef WIN32
+termios orig_attr;
+#endif
+
+} // namespace
+
+namespace Msp {
+namespace IO {
+
+Console::Console(unsigned n)
+{
+       if(n>2)
+               throw InvalidParameterValue("Invalid parameter for Console::Console");
+
+       mode = (n==0 ? M_READ : M_WRITE);
+
+#ifdef WIN32
+       switch(n)
+       {
+       case 0: handle = GetStdHandle(STD_INPUT_HANDLE); break;
+       case 1: handle = GetStdHandle(STD_OUTPUT_HANDLE); break;
+       case 2: handle = GetStdHandle(STD_ERROR_HANDLE); break;
+       }
+#else
+       handle = n;
+
+       if(handle==0)
+               tcgetattr(handle, &orig_attr);
+#endif
+
+       if(n==0)
+               set_events(P_INPUT);
+}
+
+Console::~Console()
+{
+#ifndef WIN32
+       if(handle==0)
+               tcsetattr(handle, TCSADRAIN, &orig_attr);
+#endif
+}
+
+void Console::set_block(bool b)
+{
+#ifdef WIN32
+       // XXX Dunno how to do this in win32
+       (void)b;
+#else
+       int flags = fcntl(0, F_GETFL);
+       flags = (flags&~O_NONBLOCK) | (b?0:O_NONBLOCK);
+       fcntl(0, F_SETFL, flags);
+#endif
+}
+
+void Console::set_local_echo(bool e)
+{
+       if(!(mode&M_READ))
+               throw InvalidState("Local echo can only be set on input console");
+
+#ifdef WIN32
+       DWORD m;
+       GetConsoleMode(handle, &m);
+       SetConsoleMode(handle, (m&~ENABLE_ECHO_INPUT) | (e?ENABLE_ECHO_INPUT:0));
+#else
+       termios t;
+       tcgetattr(0, &t);
+       t.c_lflag = (t.c_lflag&~ECHO) | (e?ECHO:0);
+       tcsetattr(0, TCSADRAIN, &t);
+#endif
+}
+
+void Console::set_line_buffer(bool l)
+{
+       if(!(mode&M_READ))
+               throw InvalidState("Line buffering can only be set on input console");
+
+#ifdef WIN32
+       DWORD m;
+       GetConsoleMode(handle, &m);
+       SetConsoleMode(handle, (m&~ENABLE_LINE_INPUT) | (l?ENABLE_LINE_INPUT:0));
+#else
+       // XXX ICANON does more than just set line buffering, may need a bit more thought
+       termios t;
+       tcgetattr(0, &t);
+       t.c_lflag = (t.c_lflag&~ICANON) | (l?ICANON:0);
+       tcsetattr(0, TCSADRAIN, &t);
+#endif
+}
+
+void Console::get_size(unsigned &rows, unsigned &cols)
+{
+       if(!(mode&M_WRITE))
+               throw InvalidState("Size can only be queried from an output console");
+
+#ifdef WIN32
+       // XXX Figure out how to do this
+       rows = 24;
+       cols = 80;
+#else
+       struct winsize wsz;
+       ioctl(handle, TIOCGWINSZ, &wsz);
+       rows = wsz.ws_row;
+       cols = wsz.ws_col;
+#endif
+}
+
+unsigned Console::do_write(const char *buf, unsigned len)
+{
+       if(!(mode&M_WRITE))
+               throw InvalidState("Console is not writable");
+
+#ifdef WIN32
+       DWORD ret;
+       if(!WriteFile(handle, buf, len, &ret, 0))
+               throw SystemError("Writing to console failed", GetLastError());
+#else
+       int ret = ::write(handle, buf, len);
+       if(ret==-1)
+               throw SystemError("Writing to console failed", errno);
+#endif
+
+       return ret;
+}
+
+unsigned Console::do_read(char *buf, unsigned len)
+{
+       if(!(mode&M_READ))
+               throw InvalidState("Console is not readable");
+
+#ifdef WIN32
+       DWORD ret;
+       if(!ReadFile(handle, buf, len, &ret, 0))
+               throw SystemError("Reading from console failed", GetLastError());
+#else
+       int ret = ::read(handle, buf, len);
+       if(ret==-1)
+       {
+               if(errno==EAGAIN)
+                       return 0;
+               else
+                       throw SystemError("Reading from console failed", errno);
+       }
+       else if(ret==0)
+               eof_flag = true;
+#endif
+
+       return ret;
+}
+
+Handle Console::get_event_handle()
+{
+       return 0;
+}
+
+Console &Console::instance(unsigned n)
+{
+       static Console in(0);
+       static Console out(1);
+       static Console err(2);
+
+       switch(n)
+       {
+       case 0: return in;
+       case 1: return out;
+       case 2: return err;
+       }
+
+       throw InvalidParameterValue("Unknown Console instance requested");
+}
+
+Console &cin = Console::instance(0);
+Console &cout = Console::instance(1);
+Console &cerr = Console::instance(2);
+
+} // namespace IO
+} // namespace Msp

diff --git a/source/io/console.h b/source/io/console.h
new file mode 100644 (file)
index 0000000..3c0bb71
--- /dev/null
+++ b/source/io/console.h
@@ -0,0 +1,56 @@
+#ifndef MSP_IO_CONSOLE_H_
+#define MSP_IO_CONSOLE_H_
+
+#include "base.h"
+
+namespace Msp {
+namespace IO {
+
+/**
+Provides access to standard input, output and error streams.  This class can't
+be instantiated directly - use one of the cin, cout and cerr references
+instead.
+*/
+class Console: public Base
+{
+private:
+       Handle handle;
+
+       Console(unsigned);
+public:
+       ~Console();
+
+       virtual void set_block(bool);
+       
+       /** If local echo is enabled, characters will appear on the console as they
+       are typed.  Can only be used on an input Console.  */
+       void set_local_echo(bool);
+
+       /** If line buffering is enabled, input will only be available when a
+       newline is encountered.  On some systems, this may also enable line editing.
+       Can only be used on an input Console.
+       */
+       void set_line_buffer(bool);
+
+       /** Retrieves the size of the Console.  Can only be used on an output
+       Console. */
+       void get_size(unsigned &rows, unsigned &cols);
+
+protected:
+       virtual unsigned do_write(const char *, unsigned);
+       virtual unsigned do_read(char *, unsigned);
+
+public:
+       virtual Handle get_event_handle();
+
+       static Console &instance(unsigned);
+};
+
+extern Console &cin;
+extern Console &cout;
+extern Console &cerr;
+
+} // namespace IO
+} // namespace Msp
+
+#endif

diff --git a/source/io/eventdispatcher.cpp b/source/io/eventdispatcher.cpp
new file mode 100644 (file)
index 0000000..06a594f
--- /dev/null
+++ b/source/io/eventdispatcher.cpp
@@ -0,0 +1,75 @@
+#include <msp/time/units.h>
+#include "base.h"
+#include "eventdispatcher.h"
+#include "poll.h"
+
+namespace Msp {
+namespace IO {
+
+EventDispatcher::EventDispatcher()
+{ }
+
+void EventDispatcher::add(Base &obj)
+{
+       SlotMap::iterator i = objects.find(&obj);
+       if(i==objects.end())
+       {
+               i = objects.insert(SlotMap::value_type(&obj, Slot(&obj))).first;
+               i->second.evch_conn = obj.signal_events_changed.connect(sigc::bind(sigc::mem_fun(this, &EventDispatcher::object_events_changed), &obj));
+               i->second.del_conn = obj.signal_deleted.connect(sigc::bind(sigc::mem_fun(this, &EventDispatcher::object_deleted), &obj));
+
+               if(obj.get_events())
+                       poller.set_object(obj, obj.get_events());
+       }
+}
+
+void EventDispatcher::remove(Base &obj)
+{
+       SlotMap::iterator i = objects.find(&obj);
+       if(i!=objects.end())
+       {
+               i->second.evch_conn.disconnect();
+               i->second.del_conn.disconnect();
+               objects.erase(i);
+
+               poller.set_object(obj, P_NONE);
+       }
+}
+
+void EventDispatcher::tick()
+{
+       if(objects.empty())
+               return;
+
+       if(poller.poll()>0)
+               dispatch();
+}
+
+void EventDispatcher::tick(const Time::TimeDelta &dt)
+{
+       if(objects.empty())
+               return;
+
+       if(poller.poll(dt)>0)
+               dispatch();
+}
+
+void EventDispatcher::object_events_changed(PollEvent ev, Base *obj)
+{
+       poller.set_object(*obj, ev);
+}
+
+void EventDispatcher::object_deleted(Base *obj)
+{
+       remove(*obj);
+}
+
+void EventDispatcher::dispatch()
+{
+       const Poller::SlotSeq &result = poller.get_result();
+       for(Poller::SlotSeq::const_iterator i=result.begin(); i!=result.end(); ++i)
+               i->object->event(i->events);
+}
+
+} // namespace IO
+} // namespace Msp

diff --git a/source/io/eventdispatcher.h b/source/io/eventdispatcher.h
new file mode 100644 (file)
index 0000000..7e89d47
--- /dev/null
+++ b/source/io/eventdispatcher.h
@@ -0,0 +1,55 @@
+#ifndef EVENTDISPATCHER_H_
+#define EVENTDISPATCHER_H_
+
+#include <sigc++/connection.h>
+#include <sigc++/trackable.h>
+#include "poll.h"
+
+namespace Msp {
+namespace IO {
+
+/**
+Put your I/O objects inside one of these to get signaled when something happens
+on some of them.
+*/
+class EventDispatcher: public sigc::trackable
+{
+private:
+       struct Slot
+       {
+               Base *obj;
+               sigc::connection evch_conn;
+               sigc::connection del_conn;
+
+               Slot(Base *o): obj(o) { }
+       };
+
+       typedef std::map<Base *, Slot> SlotMap;
+
+       Poller poller;
+       SlotMap objects;
+
+public:
+       EventDispatcher();
+
+       void add(Base &);
+       void remove(Base &);
+
+       /** Checks for and dispatches events.  If there are no events available,
+       blocks until there are. */
+       void tick();
+
+       /** Checks for and dispatches events.  If there are no events available,
+       waits at most the specified time before returning. */
+       void tick(const Time::TimeDelta &);
+
+private:
+       void object_events_changed(PollEvent, Base *);
+       void object_deleted(Base *);
+       void dispatch();
+};
+
+} // namespace IO
+} // namespace Msp
+
+#endif

diff --git a/source/io/except.h b/source/io/except.h
new file mode 100644 (file)
index 0000000..5770f64
--- /dev/null
+++ b/source/io/except.h
@@ -0,0 +1,22 @@
+#ifndef MSP_IO_EXCEPT_H_
+#define MSP_IO_EXCEPT_H_
+
+#include <msp/core/except.h>
+
+namespace Msp {
+namespace IO {
+
+class FileNotFound: public Exception
+{
+public:
+       FileNotFound(const std::string &w_, const std::string &f): Exception(w_), filename(f) { }
+       const std::string &get_filename() { return filename; }
+       ~FileNotFound() throw() { }
+private:
+       std::string filename;
+};
+
+} // namespace IO
+} // namespace Msp
+
+#endif

diff --git a/source/io/file.cpp b/source/io/file.cpp
new file mode 100644 (file)
index 0000000..2990d5c
--- /dev/null
+++ b/source/io/file.cpp
@@ -0,0 +1,242 @@
+#ifndef WIN32
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+#endif
+#include <msp/strings/formatter.h>
+#include "except.h"
+#include "file.h"
+
+using namespace std;
+
+namespace Msp {
+namespace IO {
+
+File::File(const string &fn, Mode m, CreateMode cm)
+{
+       if(!(m&M_RDWR))
+               throw InvalidParameterValue("Invalid read/write mode");
+       if(cm&~(C_CREATE|C_TRUNCATE))
+               throw InvalidParameterValue("Invalid create mode");
+
+       mode = m;
+
+#ifdef WIN32
+       int flags = 0;
+       int create_flags = OPEN_EXISTING;
+
+       if(mode&M_READ)
+               flags |= GENERIC_READ;
+       else if(mode&M_WRITE)
+       {
+               flags |= GENERIC_WRITE;
+
+               switch(static_cast<int>(cm))
+               {
+               case C_NONE:     create_flags = OPEN_EXISTING; break;
+               case C_CREATE:   create_flags = OPEN_ALWAYS; break;
+               case C_TRUNCATE: create_flags = TRUNCATE_EXISTING; break;
+               case C_CREATE+C_TRUNCATE: create_flags = CREATE_ALWAYS; break;
+               }
+       }
+
+       handle = CreateFile(fn.c_str(), flags, 0, 0, create_flags, FILE_ATTRIBUTE_NORMAL, 0);
+       if(handle==INVALID_HANDLE_VALUE)
+       {
+               int err = GetLastError();
+               if(err==ERROR_FILE_NOT_FOUND)
+                       throw FileNotFound("Can't find file "+fn, fn);
+               else
+                       throw SystemError(format("Can't open file '%s'", fn), GetLastError());
+       }
+#else
+       int flags = 0;
+       switch(mode&M_RDWR)
+       {
+       case M_READ:  flags |= O_RDONLY; break;
+       case M_WRITE: flags |= O_WRONLY; break;
+       case M_RDWR:  flags |= O_RDWR; break;
+       default:;
+       }
+
+       if(mode&M_WRITE)
+       {
+               if(cm&C_CREATE)
+                       flags |= O_CREAT;
+               if(cm&C_TRUNCATE)
+                       flags |= O_TRUNC;
+       }
+       if(mode&M_APPEND)
+               flags |= O_APPEND;
+       if(mode&M_NONBLOCK)
+               flags |= O_NONBLOCK;
+
+       handle = ::open(fn.c_str(), flags, 0666);
+       if(handle==-1)
+       {
+               int err = errno;
+               if(err==ENOENT)
+                       throw FileNotFound("Can't find file "+fn, fn);
+               else
+                       throw SystemError(format("Can't open file '%s'", fn), err);
+       }
+#endif
+
+       set_events(P_INPUT);
+}
+
+File::~File()
+{
+       close();
+}
+
+void File::close()
+{
+       if(handle==MSP_IO_INVALID_HANDLE)
+               return;
+
+       set_events(P_NONE);
+
+       signal_flush_required.emit();
+
+#ifdef WIN32
+       CloseHandle(handle);
+#else
+       ::close(handle);
+#endif
+
+       handle = MSP_IO_INVALID_HANDLE;
+       signal_closed.emit();
+}
+
+void File::set_block(bool b)
+{
+       check_access(M_NONE);
+
+       mode = (mode&~M_NONBLOCK);
+       if(b)
+               mode = (mode|M_NONBLOCK);
+#ifndef WIN32
+       int flags = fcntl(handle, F_GETFD);
+       fcntl(handle, F_SETFL, (flags&O_NONBLOCK)|(b?0:O_NONBLOCK));
+#endif
+}
+
+unsigned File::do_write(const char *buf, unsigned size)
+{
+       check_access(M_WRITE);
+
+       if(size==0)
+               return 0;
+
+#ifdef WIN32
+       if(mode&M_APPEND)
+               seek(0, S_END);
+       DWORD ret;
+       if(WriteFile(handle, buf, size, &ret, 0)==0)
+               throw SystemError("Writing to file failed", GetLastError());
+#else
+       int ret = ::write(handle, buf, size);
+       if(ret==-1)
+       {
+               if(errno==EAGAIN)
+                       return 0;
+               else
+                       throw SystemError("Writing to file failed", errno);
+       }
+#endif
+
+       return ret;
+}
+
+unsigned File::do_read(char *buf, unsigned size)
+{
+       check_access(M_READ);
+
+       if(size==0)
+               return 0;
+
+#ifdef WIN32
+       DWORD ret;
+       if(ReadFile(handle, buf, size, &ret, 0)==0)
+               throw SystemError("Reading from file failed", GetLastError());
+#else
+       int ret = ::read(handle, buf, size);
+       if(ret==-1)
+       {
+               if(errno==EAGAIN)
+                       return 0;
+               else
+                       throw SystemError("Reading from file failed", errno);
+       }
+#endif
+
+       if(ret==0)
+       {
+               eof_flag = true;
+               signal_end_of_file.emit();
+       }
+
+       return ret;
+}
+
+void File::sync()
+{
+#ifndef WIN32
+       signal_flush_required.emit();
+
+       fsync(handle);
+#endif
+}
+
+int File::seek(int off, SeekType st)
+{
+       check_access(M_NONE);
+
+       signal_flush_required.emit();
+
+       int type = sys_seek_type(st);
+#ifdef WIN32
+       DWORD ret = SetFilePointer(handle, off, 0, type);
+       if(ret==INVALID_SET_FILE_POINTER)
+               throw SystemError("Seek failed", GetLastError());
+#else
+       int ret = lseek(handle, off, type);
+       if(ret==-1)
+               throw SystemError("Seek failed", errno);
+#endif
+
+       eof_flag = false;
+
+       return ret;
+}
+
+int File::tell() const
+{
+       check_access(M_NONE);
+
+#ifdef WIN32
+       DWORD ret = SetFilePointer(handle, 0, 0, FILE_CURRENT);
+       if(ret==INVALID_SET_FILE_POINTER)
+               throw SystemError("Tell failed", GetLastError());
+#else
+       int ret = lseek(handle, 0, SEEK_CUR);
+       if(ret==-1)
+               throw SystemError("Tell failed", errno);
+#endif
+
+       return ret;
+}
+
+void File::check_access(Mode m) const
+{
+       if(handle==MSP_IO_INVALID_HANDLE)
+               throw InvalidState("File is not open");
+       if(m==M_READ && !(mode&M_READ))
+               throw InvalidState("File is not readable");
+       if(m==M_WRITE && !(mode&M_WRITE))
+               throw InvalidState("File is not writable");
+}
+
+} // namespace IO
+} // namespace Msp

diff --git a/source/io/file.h b/source/io/file.h
new file mode 100644 (file)
index 0000000..05aaf95
--- /dev/null
+++ b/source/io/file.h
@@ -0,0 +1,77 @@
+#ifndef MSP_IO_FILE_H_
+#define MSP_IO_FILE_H_
+
+#include <string>
+#include "base.h"
+#include "buffered.h"
+#include "filtered.h"
+#include "seek.h"
+
+namespace Msp {
+namespace IO {
+
+/**
+A class for reading and writing files.
+
+Non-blocking mode is not supported on Win32.
+*/
+class File: public Base
+{
+public:
+       enum CreateMode
+       {
+               C_NONE = 0,
+               C_CREATE = 1,
+               C_TRUNCATE = 2
+       };
+
+private:
+       Handle handle;
+
+public:
+       /** Creates a new file object and opens it.  If the create flag is set and
+       write access is requested and the file does exist, it is created.  Otherwise
+       a missing file is an error. */
+       File(const std::string &, Mode = M_READ, CreateMode = CreateMode(C_CREATE+C_TRUNCATE));
+       virtual ~File();
+
+       /** Closes the file.  Any attempt to access the file after this will cause
+       an exception to be thrown. */
+       void close();
+
+       void set_block(bool);
+
+protected:
+       virtual unsigned do_write(const char *, unsigned);
+       virtual unsigned do_read(char *, unsigned);
+
+public:
+       virtual void sync();
+
+       /** Changes the read/write offset of the file.  Returns the new offset. */
+       virtual int seek(int, SeekType);
+       
+       /** Returns the current read/write offset of the file. */
+       virtual int tell() const;
+
+       virtual Handle get_event_handle() { return handle; }
+
+private:
+       void check_access(Mode) const;
+};
+
+inline File::CreateMode operator|(File::CreateMode m, File::CreateMode n)
+{ return File::CreateMode(static_cast<int>(m)|static_cast<int>(n)); }
+
+inline File::CreateMode operator&(File::CreateMode m, File::CreateMode n)
+{ return File::CreateMode(static_cast<int>(m)&static_cast<int>(n)); }
+
+inline File::CreateMode operator~(File::CreateMode m)
+{ return File::CreateMode(~static_cast<int>(m)); }
+
+typedef Filtered<File, Buffered> BufferedFile;
+
+} // namespace IO
+} // namespace Msp
+
+#endif

diff --git a/source/io/filtered.h b/source/io/filtered.h
new file mode 100644 (file)
index 0000000..0d323ec
--- /dev/null
+++ b/source/io/filtered.h
@@ -0,0 +1,66 @@
+#ifndef MSP_IO_FILTERED_H_
+#define MSP_IO_FILTERED_H_
+
+namespace Msp {
+namespace IO {
+
+template<typename B, typename F>
+class Filtered: public B
+{
+private:
+       struct Activator
+       {
+               Filtered &f;
+
+               Activator(Filtered &f_): f(f_) { f.active = true; }
+               ~Activator() { f.active = false; }
+       };
+
+       F filter;
+       bool active;
+
+public:
+       Filtered(): filter(*this), active(false) { }
+       ~Filtered() { active = true; }
+
+       template<typename A0>
+       Filtered(A0 a0): B(a0), filter(*this), active(false) { }
+
+       template<typename A0, typename A1>
+       Filtered(A0 a0, A1 a1): B(a0, a1), filter(*this), active(false) { }
+
+protected:
+       virtual unsigned do_write(const char *b, unsigned s)
+       {
+               if(!active)
+               {
+                       Activator a(*this);
+                       return filter.write(b, s);
+               }
+               else
+                       return B::do_write(b, s);
+       }
+
+       virtual unsigned do_read(char *b, unsigned s)
+       {
+               if(!active)
+               {
+                       Activator a(*this);
+                       return filter.read(b, s);
+               }
+               else
+                       return B::do_read(b, s);
+       }
+
+public:
+       virtual unsigned put(char c) { return filter.put(c); }
+       virtual bool getline(std::string &l) { return filter.getline(l); }
+       virtual int get() { return filter.get(); }
+
+       F &get_filter() { return filter; }
+};
+
+} // namespace IO
+} // namespace Msp
+
+#endif

diff --git a/source/io/memory.cpp b/source/io/memory.cpp
new file mode 100644 (file)
index 0000000..6ea130b
--- /dev/null
+++ b/source/io/memory.cpp
@@ -0,0 +1,127 @@
+#include <algorithm>
+#include <cstring>
+#include "except.h"
+#include "memory.h"
+
+using namespace std;
+
+namespace Msp {
+namespace IO {
+
+Memory::Memory(char *d, unsigned s)
+{
+       init(d, d+s, M_RDWR);
+}
+
+Memory::Memory(char *b, char *e)
+{
+       init(b, e, M_RDWR);
+}
+
+Memory::Memory(const char *cd, unsigned s)
+{
+       char *d = const_cast<char *>(cd);
+       init(d, d+s, M_READ);
+}
+
+Memory::Memory(const char *b, const char *e)
+{
+       init(const_cast<char *>(b), const_cast<char *>(e), M_READ);
+}
+
+void Memory::init(char *b, char *e, Mode m)
+{
+       begin = b;
+       end = e;
+       pos = begin;
+       mode = m;
+}
+
+unsigned Memory::do_write(const char *buf, unsigned size)
+{
+       check_mode(M_WRITE);
+
+       size = min<unsigned>(size, end-pos);
+       memcpy(pos, buf, size);
+       pos += size;
+       return size;
+}
+
+unsigned Memory::do_read(char *buf, unsigned size)
+{
+       if(pos==end)
+       {
+               eof_flag = true;
+               return 0;
+       }
+
+       size = min<unsigned>(size, end-pos);
+       memcpy(buf, pos, size);
+       pos += size;
+       return size;
+}
+
+unsigned Memory::put(char c)
+{
+       check_mode(M_WRITE);
+       *pos++ = c;
+       return 1;
+}
+
+bool Memory::getline(string &line)
+{
+       char *nl = find(pos, end, '\n');
+       line.assign(pos, nl);
+       bool result = (nl!=pos);
+       pos = nl;
+       return result;
+}
+
+int Memory::get()
+{
+       if(pos==end)
+       {
+               eof_flag = true;
+               return -1;
+       }
+
+       return static_cast<unsigned char>(*pos++);
+}
+
+unsigned Memory::seek(int off, SeekType type)
+{
+       char *new_pos;
+       if(type==S_BEG)
+               new_pos = begin+off;
+       else if(type==S_CUR)
+               new_pos = pos+off;
+       else if(type==S_END)
+               new_pos = end+off;
+       else
+               throw InvalidParameterValue("Invalid seek type");
+
+       if(new_pos<begin || new_pos>end)
+               throw InvalidParameterValue("Invalid seek offset");
+
+       pos = new_pos;
+       return pos-begin;
+}
+
+Handle Memory::get_event_handle()
+{
+       throw Exception("Memory doesn't support events");
+}
+
+void Memory::check_mode(Mode m) const
+{
+       if(m==M_WRITE)
+       {
+               if(!(mode&M_WRITE))
+                       throw InvalidState("Memory is not writable");
+               if(pos==end)
+                       throw InvalidState("Attempt to write past end of Memory");
+       }
+}
+
+} // namespace IO
+} // namespace Msp

diff --git a/source/io/memory.h b/source/io/memory.h
new file mode 100644 (file)
index 0000000..ba6c4d8
--- /dev/null
+++ b/source/io/memory.h
@@ -0,0 +1,44 @@
+#ifndef MSP_IO_MEMORY_H_
+#define MSP_IO_MEMORY_H_
+
+#include "base.h"
+#include "seek.h"
+
+namespace Msp {
+namespace IO {
+
+class Memory: public Base
+{
+private:
+       char *begin;
+       char *end;
+       char *pos;
+
+public:
+       Memory(char *, unsigned);
+       Memory(char *, char *);
+       Memory(const char *, unsigned);
+       Memory(const char *, const char *);
+private:
+       void init(char *, char *, Mode);
+
+       virtual unsigned do_write(const char *, unsigned);
+       virtual unsigned do_read(char *, unsigned);
+public:
+       virtual unsigned put(char);
+       virtual bool getline(std::string &);
+       virtual int get();
+
+       unsigned seek(int, SeekType);
+       unsigned tell() const { return pos-begin; }
+
+       virtual Handle get_event_handle();
+
+private:
+       void check_mode(Mode) const;
+};
+
+} // namespace IO
+} // namespace Msp
+
+#endif

diff --git a/source/io/mode.h b/source/io/mode.h
new file mode 100644 (file)
index 0000000..5e103f2
--- /dev/null
+++ b/source/io/mode.h
@@ -0,0 +1,29 @@
+#ifndef MSP_IO_MODE_H_
+#define MSP_IO_MODE_H_
+
+namespace Msp {
+namespace IO {
+
+enum Mode
+{
+       M_NONE = 0,
+       M_READ = 1,
+       M_WRITE = 2,
+       M_RDWR = M_READ|M_WRITE,
+       M_APPEND = 4,
+       M_NONBLOCK = 8
+};
+
+inline Mode operator|(Mode m, Mode n)
+{ return Mode(static_cast<int>(m)|static_cast<int>(n)); }
+
+inline Mode operator&(Mode m, Mode n)
+{ return Mode(static_cast<int>(m)&static_cast<int>(n)); }
+
+inline Mode operator~(Mode m)
+{ return Mode(~static_cast<int>(m)); }
+
+} // namespace IO
+} // namespace Msp
+
+#endif

diff --git a/source/io/pipe.cpp b/source/io/pipe.cpp
new file mode 100644 (file)
index 0000000..b3735aa
--- /dev/null
+++ b/source/io/pipe.cpp
@@ -0,0 +1,182 @@
+#ifndef WIN32
+#include <fcntl.h>
+#include <errno.h>
+#endif
+#include <msp/strings/formatter.h>
+#include "pipe.h"
+
+using namespace std;
+
+namespace Msp {
+namespace IO {
+
+Pipe::Pipe()
+{
+#ifdef WIN32
+       string name = format("\\\\.\\pipe\\%u.%p", GetCurrentProcessId(), this);
+       handle[0] = CreateNamedPipe(name.c_str(), PIPE_ACCESS_INBOUND|FILE_FLAG_OVERLAPPED, PIPE_TYPE_BYTE, 1, 1024, 1024, 0, 0);
+       if(handle[0]==INVALID_HANDLE_VALUE)
+               throw SystemError("Unable to create pipe", GetLastError());
+
+       handle[1] = CreateFile(name.c_str(), GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
+       if(handle[1]==INVALID_HANDLE_VALUE)
+       {
+               unsigned err = GetLastError();
+               CloseHandle(handle[0]);
+               throw SystemError("Unable to create pipe", err);
+       }
+
+       overlapped = 0;
+       event = CreateEvent(0, true, false, 0);
+       buf_size = 1024;
+       buffer = new char[buf_size];
+       buf_avail = 0;
+       buf_next = buffer;
+#else
+       if(pipe(handle)==-1)
+               throw SystemError("Unable to create pipe", errno);
+#endif
+
+       set_events(P_INPUT);
+}
+
+Pipe::~Pipe()
+{
+       close();
+}
+
+void Pipe::close()
+{
+       set_events(P_NONE);
+
+       signal_flush_required.emit();
+#ifdef WIN32
+       CloseHandle(handle[0]);
+       CloseHandle(handle[1]);
+#else
+       ::close(handle[0]);
+       ::close(handle[1]);
+       signal_closed.emit();
+#endif
+}
+
+void Pipe::set_block(bool b)
+{
+       mode = (mode&~M_NONBLOCK);
+       if(b)
+               mode = (mode|M_NONBLOCK);
+
+#ifndef WIN32
+       int flags = fcntl(handle[0], F_GETFD);
+       fcntl(handle[0], F_SETFL, (flags&O_NONBLOCK)|(b?0:O_NONBLOCK));
+       flags = fcntl(handle[1], F_GETFD);
+       fcntl(handle[1], F_SETFL, (flags&O_NONBLOCK)|(b?0:O_NONBLOCK));
+#endif
+}
+
+unsigned Pipe::do_write(const char *buf, unsigned size)
+{
+       if(size==0)
+               return 0;
+
+#ifdef WIN32
+       DWORD ret;
+       if(!WriteFile(handle[1], buf, size, &ret, 0))
+               throw SystemError("Writing to pipe failed", GetLastError());
+#else
+       int ret = ::write(handle[1], buf, size);
+       if(ret==-1)
+       {
+               if(errno==EAGAIN)
+                       return 0;
+               else
+                       throw SystemError("Writing to pipe failed", errno);
+       }
+#endif
+
+       return ret;
+}
+
+unsigned Pipe::do_read(char *buf, unsigned size)
+{
+       if(size==0)
+               return 0;
+
+#ifdef WIN32
+       // Initiate overlapped read if needed
+       get_event_handle();
+
+       if(overlapped)
+       {
+               DWORD ret;
+               if(!GetOverlappedResult(handle[0], overlapped, &ret, !buf_avail))
+                       throw SystemError("Reading from pipe failed", GetLastError());
+               else
+               {
+                       buf_avail += ret;
+                       delete overlapped;
+                       overlapped = 0;
+               }
+       }
+
+       unsigned ret = min(buf_avail, size);
+       memcpy(buf, buf_next, ret);
+       buf_next += ret;
+       buf_avail -= ret;
+
+       // Initiate another overlapped read in case someone is polling us
+       get_event_handle();
+#else
+       int ret = ::read(handle[0], buf, size);
+       if(ret==-1)
+       {
+               if(errno==EAGAIN)
+                       return 0;
+               else
+                       throw SystemError("Reading from pipe failed", errno);
+       }
+#endif
+
+       if(ret==0)
+       {
+               eof_flag = true;
+               signal_end_of_file.emit();
+       }
+
+       return ret;
+}
+
+Handle Pipe::get_event_handle()
+{
+#ifdef WIN32
+       if(!overlapped && !buf_avail)
+       {
+               overlapped = new OVERLAPPED;
+               memset(overlapped, 0, sizeof(OVERLAPPED));
+               overlapped->hEvent = event;
+
+               DWORD ret;
+               buf_next = buffer;
+               if(!ReadFile(handle[0], buffer, buf_size, &ret, overlapped))
+               {
+                       unsigned err = GetLastError();
+                       if(err!=ERROR_IO_PENDING)
+                               throw SystemError("Failed to start an overlapped read", err);
+               }
+               else
+               {
+                       buf_avail = ret;
+                       delete overlapped;
+                       overlapped = 0;
+                       SetEvent(event);
+               }
+       }
+
+       return event;
+#else
+       return handle[0];
+#endif
+}
+
+} // namespace IO
+} // namespace Msp

diff --git a/source/io/pipe.h b/source/io/pipe.h
new file mode 100644 (file)
index 0000000..71edf7e
--- /dev/null
+++ b/source/io/pipe.h
@@ -0,0 +1,41 @@
+#ifndef MSP_IO_PIPE_H_
+#define MSP_IO_PIPE_H_
+
+#include "base.h"
+
+namespace Msp {
+namespace IO {
+
+class Pipe: public Base
+{
+private:
+       Handle handle[2];
+#ifdef WIN32
+       OVERLAPPED *overlapped;
+       Handle event;
+       unsigned buf_size;
+       char *buffer;
+       unsigned buf_avail;
+       char *buf_next;
+#endif
+
+public:
+       Pipe();
+       ~Pipe();
+
+       void close();
+
+       void set_block(bool);
+
+protected:
+       virtual unsigned do_write(const char *, unsigned);
+       virtual unsigned do_read(char *, unsigned);
+
+public:
+       virtual Handle get_event_handle();
+};
+
+} // namespace IO
+} // namespace Msp
+
+#endif

diff --git a/source/io/poll.cpp b/source/io/poll.cpp
new file mode 100644 (file)
index 0000000..dce1912
--- /dev/null
+++ b/source/io/poll.cpp
@@ -0,0 +1,212 @@
+#include <errno.h>
+#include <msp/strings/formatter.h>
+#include <msp/time/units.h>
+#include "except.h"
+#include "base.h"
+#include "poll.h"
+
+namespace {
+
+using namespace Msp;
+using namespace Msp::IO;
+
+inline int sys_poll_event(PollEvent event)
+{
+       int result = 0;
+
+       if(event&~(P_INPUT|P_PRIO|P_OUTPUT))
+               throw InvalidParameterValue("Invalid poll events");
+
+#ifndef WIN32
+       if(event&P_INPUT)
+               result |= POLLIN;
+       if(event&P_PRIO)
+               result |= POLLPRI;
+       if(event&P_OUTPUT)
+               result |= POLLOUT;
+#endif
+
+       return result;
+}
+
+inline PollEvent poll_event_from_sys(int event)
+{
+       PollEvent result = P_NONE;
+
+#ifdef WIN32
+       // Stop the compiler from complaining about unused parameter
+       event = event;
+#else
+       if(event&POLLIN)
+               result = result|P_INPUT;
+       if(event&POLLPRI)
+               result = result|P_PRIO;
+       if(event&POLLOUT)
+               result = result|P_OUTPUT;
+       if(event&POLLERR)
+               result = result|P_ERROR;
+#endif
+
+       return result;
+}
+
+inline PollEvent do_poll(Base &obj, PollEvent pe, int timeout)
+{
+#ifdef WIN32
+       if(timeout<0)
+               timeout = INFINITE;
+
+       DWORD ret = WaitForSingleObject(obj.get_event_handle(), timeout);
+       if(ret==WAIT_OBJECT_0)
+               return pe;
+       else if(ret==WAIT_FAILED)
+               throw SystemError("Poll failed", GetLastError());
+
+       return P_NONE;
+#else
+       pollfd pfd = {obj.get_event_handle(), sys_poll_event(pe), 0};
+
+       int ret = ::poll(&pfd, 1, timeout);
+       if(ret==-1)
+       {
+               if(errno==EINTR)
+                       return P_NONE;
+               else
+                       throw SystemError("Poll failed", errno);
+       }
+
+       return poll_event_from_sys(pfd.revents);
+#endif
+}
+
+}
+
+namespace Msp {
+namespace IO {
+
+Poller::Poller():
+       pfd_dirty(false)
+{ }
+
+void Poller::set_object(Base &obj, PollEvent ev)
+{
+       // Verify that the object has an event handle
+       if(ev)
+               obj.get_event_handle();
+
+       SlotMap::iterator i = objects.find(&obj);
+       if(i!=objects.end())
+       {
+               if(ev)
+                       i->second.events = ev;
+               else
+                       objects.erase(i);
+
+               pfd_dirty = true;
+       }
+       else if(ev)
+       {
+#ifdef WIN32
+               if(objects.size()>=MAXIMUM_WAIT_OBJECTS)
+                       throw InvalidState("Maximum number of wait objects reached");
+#endif
+               objects.insert(SlotMap::value_type(&obj, Slot(&obj, ev)));
+
+               pfd_dirty = true;
+       }
+}
+
+int Poller::poll()
+{
+       return do_poll(-1);
+}
+
+int Poller::poll(const Time::TimeDelta &timeout)
+{
+       if(timeout<Time::zero)
+               throw InvalidParameterValue("Invalid timeout");
+
+       return do_poll(static_cast<int>(timeout/Time::msec));
+}
+
+void Poller::rebuild_pfd()
+{
+       pfd.clear();
+
+       pollfd p;
+
+       for(SlotMap::iterator i=objects.begin(); i!=objects.end(); ++i)
+       {
+               p.fd = i->second.object->get_event_handle();
+#ifndef WIN32
+               p.events = sys_poll_event(i->second.events);
+#endif
+               pfd.push_back(p);
+       }
+
+       pfd_dirty = false;
+}
+
+int Poller::do_poll(int timeout)
+{
+       if(pfd_dirty)
+               rebuild_pfd();
+
+       poll_result.clear();
+
+#ifdef WIN32
+       if(timeout<0)
+               timeout = INFINITE;
+
+       DWORD ret = WaitForMultipleObjects(pfd.size(), &pfd.front().fd, false, timeout);
+       if(/*ret>=WAIT_OBJECT_0 &&*/ ret<WAIT_OBJECT_0+pfd.size())
+       {
+               SlotMap::iterator i = objects.begin();
+               advance(i, ret-WAIT_OBJECT_0);
+               poll_result.push_back(Slot(i->second.object, i->second.events));
+
+               return 1;
+       }
+       else if(ret==WAIT_FAILED)
+               throw SystemError("Poll failed", GetLastError());
+
+       return 0;
+#else
+       int ret = ::poll(&pfd.front(), pfd.size(), timeout);
+       if(ret==-1)
+       {
+               if(errno==EINTR)
+                       return 0;
+               else
+                       throw SystemError("Poll failed", errno);
+       }
+
+       int n = ret;
+       SlotMap::iterator j = objects.begin();
+       for(std::vector<pollfd>::iterator i=pfd.begin(); (i!=pfd.end() && n>0); ++i,++j)
+               if(i->revents)
+               {
+                       poll_result.push_back(Slot(j->second.object, poll_event_from_sys(i->revents)));
+                       --n;
+               }
+
+       return ret;
+#endif
+}
+
+
+PollEvent poll(Base &obj, PollEvent pe)
+{
+       return do_poll(obj, pe, -1);
+}
+
+PollEvent poll(Base &obj, PollEvent pe, const Time::TimeDelta &timeout)
+{
+       if(timeout<Time::zero)
+               throw InvalidParameterValue("Invalid timeout");
+
+       return do_poll(obj, pe, static_cast<int>(timeout/Time::msec));
+}
+
+} // namespace IO
+} // namespace Msp

diff --git a/source/io/poll.h b/source/io/poll.h
new file mode 100644 (file)
index 0000000..6367d8f
--- /dev/null
+++ b/source/io/poll.h
@@ -0,0 +1,82 @@
+#ifndef MSP_IO_POLL_H_
+#define MSP_IO_POLL_H_
+
+#ifndef WIN32
+#include <poll.h>
+#endif
+#include <list>
+#include <map>
+#include <vector>
+#include <msp/time/timedelta.h>
+#include "types.h"
+
+namespace Msp {
+namespace IO {
+
+class Base;
+
+enum PollEvent
+{
+       P_NONE = 0,
+       P_INPUT = 1,
+       P_PRIO = 2,
+       P_OUTPUT = 4,
+       P_ERROR = 8
+};
+
+inline PollEvent operator|(PollEvent e, PollEvent f)
+{ return PollEvent(static_cast<int>(e)|static_cast<int>(f)); }
+
+inline PollEvent operator&(PollEvent e, PollEvent f)
+{ return PollEvent(static_cast<int>(e)&static_cast<int>(f)); }
+
+inline PollEvent operator~(PollEvent e)
+{ return PollEvent(~static_cast<int>(e)); }
+
+
+class Poller
+{
+public:
+       struct Slot
+       {
+               Base *object;
+               PollEvent events;
+
+               Slot(Base *o, PollEvent e): object(o), events(e) { }
+       };
+
+       typedef std::list<Slot> SlotSeq;
+private:
+       typedef std::map<Base *, Slot> SlotMap;
+
+#ifdef WIN32
+       struct pollfd
+       {
+               Handle fd;
+       };
+#endif
+
+       SlotMap objects;
+       std::vector<pollfd> pfd;
+       bool pfd_dirty;
+       SlotSeq poll_result;
+
+       void rebuild_pfd();
+       int do_poll(int);
+
+public:
+       Poller();
+
+       void set_object(Base &, PollEvent);
+       int poll();
+       int poll(const Time::TimeDelta &);
+       const SlotSeq &get_result() const { return poll_result; }
+};
+
+PollEvent poll(Base &, PollEvent);
+PollEvent poll(Base &, PollEvent, const Time::TimeDelta &);
+
+} // namespace IO
+} // namespace Msp
+
+#endif

diff --git a/source/io/print.h b/source/io/print.h
new file mode 100644 (file)
index 0000000..65744cb
--- /dev/null
+++ b/source/io/print.h
@@ -0,0 +1,66 @@
+#ifndef MSP_IO_PRINT_H_
+#define MSP_IO_PRINT_H_
+
+#include <msp/strings/formatter.h>
+#include "base.h"
+#include "console.h"
+
+namespace Msp {
+namespace IO {
+
+/**
+Writes a string to an I/O object.  Same as o.write(f).  Provided for
+completeness with the other print functions.
+*/
+inline unsigned print(Base &o, const std::string &f)
+{ return o.write(f); }
+
+template<typename A1>
+inline unsigned print(Base &o, const std::string &f, A1 a1)
+{ return print(o, format(f, a1)); }
+
+template<typename A1, typename A2>
+inline unsigned print(Base &o, const std::string &f, A1 a1, A2 a2)
+{ return print(o, format(f, a1, a2)); }
+
+template<typename A1, typename A2, typename A3>
+inline unsigned print(Base &o, const std::string &f, A1 a1, A2 a2, A3 a3)
+{ return print(o, format(f, a1, a2, a3)); }
+
+template<typename A1, typename A2, typename A3, typename A4>
+inline unsigned print(Base &o, const std::string &f, A1 a1, A2 a2, A3 a3, A4 a4)
+{ return print(o, format(f, a1, a2, a3, a4)); }
+
+template<typename A1, typename A2, typename A3, typename A4, typename A5>
+inline unsigned print(Base &o, const std::string &f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{ return print(o, format(f, a1, a2, a3, a4, a5)); }
+
+/* The following functions print to console */
+
+inline unsigned print(const std::string &f)
+{ return print(cout, f); }
+
+template<typename A1>
+inline unsigned print(const std::string &f, A1 a1)
+{ return print(cout, f, a1); }
+
+template<typename A1, typename A2>
+inline unsigned print(const std::string &f, A1 a1, A2 a2)
+{ return print(cout, f, a1, a2); }
+
+template<typename A1, typename A2, typename A3>
+inline unsigned print(const std::string &f, A1 a1, A2 a2, A3 a3)
+{ return print(cout, f, a1, a2, a3); }
+
+template<typename A1, typename A2, typename A3, typename A4>
+inline unsigned print(const std::string &f, A1 a1, A2 a2, A3 a3, A4 a4)
+{ return print(cout, f, a1, a2, a3, a4); }
+
+template<typename A1, typename A2, typename A3, typename A4, typename A5>
+inline unsigned print(const std::string &f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{ return print(cout, f, a1, a2, a3, a4, a5); }
+
+} // namespace IO
+} // namespace Msp
+
+#endif

diff --git a/source/io/seek.cpp b/source/io/seek.cpp
new file mode 100644 (file)
index 0000000..b10c5a0
--- /dev/null
+++ b/source/io/seek.cpp
@@ -0,0 +1,32 @@
+#ifdef WIN32
+#include <windows.h>
+#endif
+#include "except.h"
+#include "seek.h"
+
+namespace Msp {
+namespace IO {
+
+int sys_seek_type(SeekType st)
+{
+#ifdef WIN32
+       if(st==S_BEG)
+               return FILE_BEGIN;
+       else if(st==S_CUR)
+               return FILE_CURRENT;
+       else if(st==S_END)
+               return FILE_END;
+#else
+       if(st==S_BEG)
+               return SEEK_SET;
+       else if(st==S_CUR)
+               return SEEK_CUR;
+       else if(st==S_END)
+               return SEEK_END;
+#endif
+
+       throw InvalidParameterValue("Invalid seek type");
+}
+
+} // namespace IO
+} // namespace Msp

diff --git a/source/io/seek.h b/source/io/seek.h
new file mode 100644 (file)
index 0000000..3c6c331
--- /dev/null
+++ b/source/io/seek.h
@@ -0,0 +1,19 @@
+#ifndef MSP_IO_SEEK_H_
+#define MSP_IO_SEEK_H_
+
+namespace Msp {
+namespace IO {
+
+enum SeekType
+{
+       S_BEG,
+       S_CUR,
+       S_END
+};
+
+extern int sys_seek_type(SeekType);
+
+} // namespace IO
+} // namespace Msp
+
+#endif

diff --git a/source/io/serial.cpp b/source/io/serial.cpp
new file mode 100644 (file)
index 0000000..ec6a198
--- /dev/null
+++ b/source/io/serial.cpp
@@ -0,0 +1,340 @@
+#ifdef WIN32
+#include <windows.h>
+#else
+#include <termios.h>
+#include <fcntl.h>
+#include <errno.h>
+#endif
+#include <msp/strings/formatter.h>
+#include "except.h"
+#include "serial.h"
+
+using namespace std;
+
+namespace {
+
+using namespace Msp;
+using namespace Msp::IO;
+
+#ifdef WIN32
+typedef DCB DeviceState;
+#else
+typedef termios DeviceState;
+#endif
+
+void get_state(Handle handle, DeviceState &state)
+{
+#ifdef WIN32
+       GetCommState(handle, &state);
+#else
+       tcgetattr(handle, &state);
+#endif
+}
+
+void set_state(Handle handle, DeviceState &state)
+{
+#ifdef WIN32
+       if(SetCommState(handle, &state)==0)
+               throw SystemError("Cannot set serial port parameters", GetLastError());
+#else
+       if(tcsetattr(handle, TCSADRAIN, &state)==-1)
+               throw SystemError("Cannot set serial port parameters", errno);
+#endif
+}
+
+void set_baud_rate(DeviceState &state, unsigned baud)
+{
+#ifdef WIN32
+       state.BaudRate = baud;
+#else
+       speed_t speed;
+       switch(baud)
+       {
+       case 0:      speed = B0; break;
+       case 50:     speed = B50; break;
+       case 75:     speed = B75; break;
+       case 110:    speed = B110; break;
+       case 134:    speed = B134; break;
+       case 150:    speed = B150; break;
+       case 200:    speed = B200; break;
+       case 300:    speed = B300; break;
+       case 600:    speed = B600; break;
+       case 1200:   speed = B1200; break;
+       case 1800:   speed = B1800; break;
+       case 2400:   speed = B2400; break;
+       case 4800:   speed = B4800; break;
+       case 9600:   speed = B9600; break;
+       case 19200:  speed = B19200; break;
+       case 38400:  speed = B38400; break;
+       case 57600:  speed = B57600; break;
+       case 115200: speed = B115200; break;
+       case 230400: speed = B230400; break;
+       default: throw InvalidParameterValue("Invalid baud rate");
+       }
+
+       cfsetospeed(&state, speed);
+       cfsetispeed(&state, speed);
+#endif
+}
+
+void set_data_bits(DeviceState &state, unsigned bits)
+{
+#ifdef WIN32
+       state.ByteSize = bits;
+#else
+       tcflag_t flag;
+       switch(bits)
+       {
+       case 5: flag = CS5; break;
+       case 6: flag = CS6; break;
+       case 7: flag = CS7; break;
+       case 8: flag = CS8; break;
+       default: throw InvalidParameterValue("Invalid data bit count");
+       }
+
+       state.c_cflag = (state.c_cflag&~CSIZE)|flag;
+#endif
+}
+
+void set_parity(DeviceState &state, Serial::Parity par)
+{
+#ifdef WIN32
+       switch(par)
+       {
+       case Serial::NONE: state.Parity = NOPARITY; break;
+       case Serial::EVEN: state.Parity = EVENPARITY; break;
+       case Serial::ODD:  state.Parity = ODDPARITY; break;
+       default: throw InvalidParameterValue("Invalid parity");
+       }
+#else
+       tcflag_t flag;
+       switch(par)
+       {
+       case Serial::NONE: flag = 0; break;
+       case Serial::EVEN: flag = PARENB; break;
+       case Serial::ODD:  flag = PARENB|PARODD; break;
+       default: throw InvalidParameterValue("Invalid parity");
+       }
+
+       state.c_cflag = (state.c_cflag&~(PARENB|PARODD))|flag;
+#endif
+}
+
+void set_stop_bits(DeviceState &state, unsigned bits)
+{
+#ifdef WIN32
+       switch(bits)
+       {
+       case 1: state.StopBits = ONESTOPBIT; break;
+       case 2: state.StopBits = TWOSTOPBITS; break;
+       default: throw InvalidParameterValue("Invalid stop bit count");
+       }
+#else
+       tcflag_t flag;
+       switch(bits)
+       {
+       case 1: flag = 0; break;
+       case 2: flag = CSTOPB; break;
+       default: throw InvalidParameterValue("Invalid stop bit count");
+       }
+
+       state.c_cflag = (state.c_cflag&~CSTOPB)|flag;
+#endif
+}
+
+}
+
+
+namespace Msp {
+namespace IO {
+
+Serial::Serial(const string &descr)
+{
+       string::size_type comma = descr.find(',');
+       string port = descr.substr(0, comma);
+
+#ifdef WIN32
+       port = "\\\\.\\"+port;
+
+       handle = CreateFile(port.c_str(), GENERIC_READ|GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
+       if(handle==INVALID_HANDLE_VALUE)
+               throw SystemError(format("Can't open serial port '%s'", port), GetLastError());
+       mode = M_READ|M_WRITE;
+
+       COMMTIMEOUTS timeouts;
+       timeouts.ReadIntervalTimeout = MAXDWORD;
+       timeouts.ReadTotalTimeoutMultiplier = MAXDWORD;
+       timeouts.ReadTotalTimeoutConstant = MAXDWORD-1;
+       timeouts.WriteTotalTimeoutMultiplier = 0;
+       timeouts.WriteTotalTimeoutConstant = 0;
+       SetCommTimeouts(handle, &timeouts);
+#else
+       if(port.compare(0, 5, "/dev/"))
+               port = "/dev/"+port;
+
+       handle = open(port.c_str(), O_RDWR);
+       if(handle==-1)
+               throw SystemError(format("Can't open serial port '%s'", port), errno);
+       mode = M_READ|M_WRITE;
+
+       termios t;
+       tcgetattr(handle, &t);
+       t.c_lflag &= ~(ECHO|ICANON);
+       t.c_oflag &= ~OPOST;
+       tcsetattr(handle, TCSADRAIN, &t);
+#endif
+
+       if(comma!=string::npos)
+       {
+               try
+               {
+                       set_parameters(descr.substr(comma+1));
+               }
+               catch(...)
+               {
+                       close();
+                       throw;
+               }
+       }
+
+       set_events(P_INPUT);
+}
+
+Serial::~Serial()
+{
+       close();
+}
+
+void Serial::close()
+{
+#ifdef WIN32
+       CloseHandle(handle);
+#else
+       ::close(handle);
+#endif
+}
+
+void Serial::set_block(bool b)
+{
+       if(b)
+               mode = mode|M_NONBLOCK;
+       else
+               mode = mode&~M_NONBLOCK;
+
+#ifndef WIN32
+       int flags = fcntl(handle, F_GETFD);
+       fcntl(handle, F_SETFL, (flags&O_NONBLOCK)|(b?0:O_NONBLOCK));
+#endif
+}
+
+void Serial::set_baud_rate(unsigned rate)
+{
+       DeviceState state;
+       get_state(handle, state);
+       ::set_baud_rate(state, rate);
+       set_state(handle, state);
+}
+
+void Serial::set_data_bits(unsigned bits)
+{
+       DeviceState state;
+       get_state(handle, state);
+       ::set_data_bits(state, bits);
+       set_state(handle, state);
+}
+
+void Serial::set_parity(Parity par)
+{
+       DeviceState state;
+       get_state(handle, state);
+       ::set_parity(state, par);
+       set_state(handle, state);
+}
+
+void Serial::set_stop_bits(unsigned bits)
+{
+       DeviceState state;
+       get_state(handle, state);
+       ::set_stop_bits(state, bits);
+       set_state(handle, state);
+}
+
+void Serial::set_parameters(const string &params)
+{
+       unsigned i;
+       for(i=0; i<params.size() && isdigit(params[i]); ++i) ;
+       if(i+4!=params.size() || params[i]!=',')
+               throw InvalidParameterValue("Invalid parameter string");
+       if(params[i+1]<'5' || params[i+1]>'8')
+               throw InvalidParameterValue("Invalid data bit count");
+       if(params[i+2]!='N' && params[i+2]!='E' && params[i+2]!='O')
+               throw InvalidParameterValue("Invalid parity");
+       if(params[i+3]!='1' && params[i+3]!='2')
+               throw InvalidParameterValue("Invalid stop bit count");
+
+       DeviceState state;
+       get_state(handle, state);
+       ::set_baud_rate(state, lexical_cast<unsigned>(params.substr(0, i)));
+       ::set_data_bits(state, params[i+1]-'0');
+       ::set_parity(state, (params[i+2]=='E' ? EVEN : params[i+2]=='O' ? ODD : NONE));
+       ::set_stop_bits(state, params[i+3]-'0');
+       set_state(handle, state);
+}
+
+unsigned Serial::do_write(const char *buf, unsigned size)
+{
+       if(size==0)
+               return 0;
+
+#ifdef WIN32
+       DWORD ret;
+       if(WriteFile(handle, buf, size, &ret, 0)==0)
+               throw SystemError("Writing to serial port failed", GetLastError());
+#else
+       int ret = ::write(handle, buf, size);
+       if(ret==-1)
+       {
+               if(errno==EAGAIN)
+                       return 0;
+               else
+                       throw SystemError("Writing to serial port failed", errno);
+       }
+#endif
+
+       return ret;
+}
+
+unsigned Serial::do_read(char *buf, unsigned size)
+{
+       if(size==0)
+               return 0;
+
+#ifdef WIN32
+       DWORD ret;
+       if(ReadFile(handle, buf, size, &ret, 0)==0)
+               throw SystemError("Reading from serial port failed", GetLastError());
+#else
+       int ret = ::read(handle, buf, size);
+       if(ret==-1)
+       {
+               if(errno==EAGAIN)
+                       return 0;
+               else
+                       throw SystemError("Reading from serial port failed", errno);
+       }
+#endif
+
+       return ret;
+}
+
+Handle Serial::get_event_handle()
+{
+#ifdef WIN32
+       throw Exception("Serial port events not supported on win32 yet");
+#else
+       return handle;
+#endif
+}
+
+} // namespace IO
+} // namespace Msp

diff --git a/source/io/serial.h b/source/io/serial.h
new file mode 100644 (file)
index 0000000..069789c
--- /dev/null
+++ b/source/io/serial.h
@@ -0,0 +1,49 @@
+#ifndef MSP_IO_SERIAL_H_
+#define MSP_IO_SERIAL_H_
+
+#include "base.h"
+
+namespace Msp {
+namespace IO {
+
+class Serial: public Base
+{
+public:
+       enum Parity
+       {
+               NONE,
+               EVEN,
+               ODD
+       };
+
+private:
+       Handle handle;
+
+public:
+       Serial(const std::string &);
+       virtual ~Serial();
+
+private:
+       void close();
+
+public:
+       virtual void set_block(bool);
+
+       void set_baud_rate(unsigned);
+       void set_data_bits(unsigned);
+       void set_parity(Parity);
+       void set_stop_bits(unsigned);
+       void set_parameters(const std::string &);
+
+private:
+       virtual unsigned do_write(const char *, unsigned);
+       virtual unsigned do_read(char *, unsigned);
+
+public:
+       virtual Handle get_event_handle();
+};
+
+} // namespace IO
+} // namespace Msp
+
+#endif

diff --git a/source/io/types.h b/source/io/types.h
new file mode 100644 (file)
index 0000000..f18b7cb
--- /dev/null
+++ b/source/io/types.h
@@ -0,0 +1,22 @@
+#ifndef MSP_IO_TYPES_H_
+#define MSP_IO_TYPES_H_
+
+#ifdef WIN32
+#include <windows.h>
+#endif
+
+namespace Msp {
+namespace IO {
+
+#ifdef WIN32
+typedef HANDLE Handle;
+#define MSP_IO_INVALID_HANDLE INVALID_HANDLE_VALUE
+#else
+typedef int Handle;
+#define MSP_IO_INVALID_HANDLE -1
+#endif
+
+} // namespace IO
+} // namespace Msp
+
+#endif

diff --git a/source/io/utils.cpp b/source/io/utils.cpp
new file mode 100644 (file)
index 0000000..eee51cc
--- /dev/null
+++ b/source/io/utils.cpp
@@ -0,0 +1,17 @@
+#include "base.h"
+#include "utils.h"
+
+namespace Msp {
+namespace IO {
+
+unsigned read_all(Base &obj, char *buf, unsigned size)
+{
+       unsigned pos = 0;
+       while(pos<size)
+               pos += obj.read(buf+pos, size-pos);
+
+       return pos;
+}
+
+} // namespace IO
+} // namespace Msp

diff --git a/source/io/utils.h b/source/io/utils.h
new file mode 100644 (file)
index 0000000..8d4f9dd
--- /dev/null
+++ b/source/io/utils.h
@@ -0,0 +1,20 @@
+#ifndef MSP_IO_UTILS_H_
+#define MSP_IO_UTILS_H_
+
+namespace Msp {
+namespace IO {
+
+class Base;
+
+/** Reads data from an object.  Does not return until the requested amount of
+data is read, regardless of the blocking mode of the object.
+
+Note: If the data is not immediately available and the object is in non-blocking
+mode, this function effectively becomes a busyloop until it can get more
+data. */
+unsigned read_all(Base &, char *, unsigned);
+
+} // namespace IO
+} // namespace Msp
+
+#endif

diff --git a/source/memory.cpp b/source/memory.cpp
deleted file mode 100644 (file)
index 6ea130b..0000000
--- a/source/memory.cpp
+++ /dev/null
@@ -1,127 +0,0 @@
-#include <algorithm>
-#include <cstring>
-#include "except.h"
-#include "memory.h"
-
-using namespace std;
-
-namespace Msp {
-namespace IO {
-
-Memory::Memory(char *d, unsigned s)
-{
-       init(d, d+s, M_RDWR);
-}
-
-Memory::Memory(char *b, char *e)
-{
-       init(b, e, M_RDWR);
-}
-
-Memory::Memory(const char *cd, unsigned s)
-{
-       char *d = const_cast<char *>(cd);
-       init(d, d+s, M_READ);
-}
-
-Memory::Memory(const char *b, const char *e)
-{
-       init(const_cast<char *>(b), const_cast<char *>(e), M_READ);
-}
-
-void Memory::init(char *b, char *e, Mode m)
-{
-       begin = b;
-       end = e;
-       pos = begin;
-       mode = m;
-}
-
-unsigned Memory::do_write(const char *buf, unsigned size)
-{
-       check_mode(M_WRITE);
-
-       size = min<unsigned>(size, end-pos);
-       memcpy(pos, buf, size);
-       pos += size;
-       return size;
-}
-
-unsigned Memory::do_read(char *buf, unsigned size)
-{
-       if(pos==end)
-       {
-               eof_flag = true;
-               return 0;
-       }
-
-       size = min<unsigned>(size, end-pos);
-       memcpy(buf, pos, size);
-       pos += size;
-       return size;
-}
-
-unsigned Memory::put(char c)
-{
-       check_mode(M_WRITE);
-       *pos++ = c;
-       return 1;
-}
-
-bool Memory::getline(string &line)
-{
-       char *nl = find(pos, end, '\n');
-       line.assign(pos, nl);
-       bool result = (nl!=pos);
-       pos = nl;
-       return result;
-}
-
-int Memory::get()
-{
-       if(pos==end)
-       {
-               eof_flag = true;
-               return -1;
-       }
-
-       return static_cast<unsigned char>(*pos++);
-}
-
-unsigned Memory::seek(int off, SeekType type)
-{
-       char *new_pos;
-       if(type==S_BEG)
-               new_pos = begin+off;
-       else if(type==S_CUR)
-               new_pos = pos+off;
-       else if(type==S_END)
-               new_pos = end+off;
-       else
-               throw InvalidParameterValue("Invalid seek type");
-
-       if(new_pos<begin || new_pos>end)
-               throw InvalidParameterValue("Invalid seek offset");
-
-       pos = new_pos;
-       return pos-begin;
-}
-
-Handle Memory::get_event_handle()
-{
-       throw Exception("Memory doesn't support events");
-}
-
-void Memory::check_mode(Mode m) const
-{
-       if(m==M_WRITE)
-       {
-               if(!(mode&M_WRITE))
-                       throw InvalidState("Memory is not writable");
-               if(pos==end)
-                       throw InvalidState("Attempt to write past end of Memory");
-       }
-}
-
-} // namespace IO
-} // namespace Msp

diff --git a/source/memory.h b/source/memory.h
deleted file mode 100644 (file)
index ba6c4d8..0000000
--- a/source/memory.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef MSP_IO_MEMORY_H_
-#define MSP_IO_MEMORY_H_
-
-#include "base.h"
-#include "seek.h"
-
-namespace Msp {
-namespace IO {
-
-class Memory: public Base
-{
-private:
-       char *begin;
-       char *end;
-       char *pos;
-
-public:
-       Memory(char *, unsigned);
-       Memory(char *, char *);
-       Memory(const char *, unsigned);
-       Memory(const char *, const char *);
-private:
-       void init(char *, char *, Mode);
-
-       virtual unsigned do_write(const char *, unsigned);
-       virtual unsigned do_read(char *, unsigned);
-public:
-       virtual unsigned put(char);
-       virtual bool getline(std::string &);
-       virtual int get();
-
-       unsigned seek(int, SeekType);
-       unsigned tell() const { return pos-begin; }
-
-       virtual Handle get_event_handle();
-
-private:
-       void check_mode(Mode) const;
-};
-
-} // namespace IO
-} // namespace Msp
-
-#endif

diff --git a/source/mode.h b/source/mode.h
deleted file mode 100644 (file)
index 5e103f2..0000000
--- a/source/mode.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#ifndef MSP_IO_MODE_H_
-#define MSP_IO_MODE_H_
-
-namespace Msp {
-namespace IO {
-
-enum Mode
-{
-       M_NONE = 0,
-       M_READ = 1,
-       M_WRITE = 2,
-       M_RDWR = M_READ|M_WRITE,
-       M_APPEND = 4,
-       M_NONBLOCK = 8
-};
-
-inline Mode operator|(Mode m, Mode n)
-{ return Mode(static_cast<int>(m)|static_cast<int>(n)); }
-
-inline Mode operator&(Mode m, Mode n)
-{ return Mode(static_cast<int>(m)&static_cast<int>(n)); }
-
-inline Mode operator~(Mode m)
-{ return Mode(~static_cast<int>(m)); }
-
-} // namespace IO
-} // namespace Msp
-
-#endif

diff --git a/source/pipe.cpp b/source/pipe.cpp
deleted file mode 100644 (file)
index b3735aa..0000000
--- a/source/pipe.cpp
+++ /dev/null
@@ -1,182 +0,0 @@
-#ifndef WIN32
-#include <fcntl.h>
-#include <errno.h>
-#endif
-#include <msp/strings/formatter.h>
-#include "pipe.h"
-
-using namespace std;
-
-namespace Msp {
-namespace IO {
-
-Pipe::Pipe()
-{
-#ifdef WIN32
-       string name = format("\\\\.\\pipe\\%u.%p", GetCurrentProcessId(), this);
-       handle[0] = CreateNamedPipe(name.c_str(), PIPE_ACCESS_INBOUND|FILE_FLAG_OVERLAPPED, PIPE_TYPE_BYTE, 1, 1024, 1024, 0, 0);
-       if(handle[0]==INVALID_HANDLE_VALUE)
-               throw SystemError("Unable to create pipe", GetLastError());
-
-       handle[1] = CreateFile(name.c_str(), GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
-       if(handle[1]==INVALID_HANDLE_VALUE)
-       {
-               unsigned err = GetLastError();
-               CloseHandle(handle[0]);
-               throw SystemError("Unable to create pipe", err);
-       }
-
-       overlapped = 0;
-       event = CreateEvent(0, true, false, 0);
-       buf_size = 1024;
-       buffer = new char[buf_size];
-       buf_avail = 0;
-       buf_next = buffer;
-#else
-       if(pipe(handle)==-1)
-               throw SystemError("Unable to create pipe", errno);
-#endif
-
-       set_events(P_INPUT);
-}
-
-Pipe::~Pipe()
-{
-       close();
-}
-
-void Pipe::close()
-{
-       set_events(P_NONE);
-
-       signal_flush_required.emit();
-#ifdef WIN32
-       CloseHandle(handle[0]);
-       CloseHandle(handle[1]);
-#else
-       ::close(handle[0]);
-       ::close(handle[1]);
-       signal_closed.emit();
-#endif
-}
-
-void Pipe::set_block(bool b)
-{
-       mode = (mode&~M_NONBLOCK);
-       if(b)
-               mode = (mode|M_NONBLOCK);
-
-#ifndef WIN32
-       int flags = fcntl(handle[0], F_GETFD);
-       fcntl(handle[0], F_SETFL, (flags&O_NONBLOCK)|(b?0:O_NONBLOCK));
-       flags = fcntl(handle[1], F_GETFD);
-       fcntl(handle[1], F_SETFL, (flags&O_NONBLOCK)|(b?0:O_NONBLOCK));
-#endif
-}
-
-unsigned Pipe::do_write(const char *buf, unsigned size)
-{
-       if(size==0)
-               return 0;
-
-#ifdef WIN32
-       DWORD ret;
-       if(!WriteFile(handle[1], buf, size, &ret, 0))
-               throw SystemError("Writing to pipe failed", GetLastError());
-#else
-       int ret = ::write(handle[1], buf, size);
-       if(ret==-1)
-       {
-               if(errno==EAGAIN)
-                       return 0;
-               else
-                       throw SystemError("Writing to pipe failed", errno);
-       }
-#endif
-
-       return ret;
-}
-
-unsigned Pipe::do_read(char *buf, unsigned size)
-{
-       if(size==0)
-               return 0;
-
-#ifdef WIN32
-       // Initiate overlapped read if needed
-       get_event_handle();
-
-       if(overlapped)
-       {
-               DWORD ret;
-               if(!GetOverlappedResult(handle[0], overlapped, &ret, !buf_avail))
-                       throw SystemError("Reading from pipe failed", GetLastError());
-               else
-               {
-                       buf_avail += ret;
-                       delete overlapped;
-                       overlapped = 0;
-               }
-       }
-
-       unsigned ret = min(buf_avail, size);
-       memcpy(buf, buf_next, ret);
-       buf_next += ret;
-       buf_avail -= ret;
-
-       // Initiate another overlapped read in case someone is polling us
-       get_event_handle();
-#else
-       int ret = ::read(handle[0], buf, size);
-       if(ret==-1)
-       {
-               if(errno==EAGAIN)
-                       return 0;
-               else
-                       throw SystemError("Reading from pipe failed", errno);
-       }
-#endif
-
-       if(ret==0)
-       {
-               eof_flag = true;
-               signal_end_of_file.emit();
-       }
-
-       return ret;
-}
-
-Handle Pipe::get_event_handle()
-{
-#ifdef WIN32
-       if(!overlapped && !buf_avail)
-       {
-               overlapped = new OVERLAPPED;
-               memset(overlapped, 0, sizeof(OVERLAPPED));
-               overlapped->hEvent = event;
-
-               DWORD ret;
-               buf_next = buffer;
-               if(!ReadFile(handle[0], buffer, buf_size, &ret, overlapped))
-               {
-                       unsigned err = GetLastError();
-                       if(err!=ERROR_IO_PENDING)
-                               throw SystemError("Failed to start an overlapped read", err);
-               }
-               else
-               {
-                       buf_avail = ret;
-                       delete overlapped;
-                       overlapped = 0;
-                       SetEvent(event);
-               }
-       }
-
-       return event;
-#else
-       return handle[0];
-#endif
-}
-
-} // namespace IO
-} // namespace Msp

diff --git a/source/pipe.h b/source/pipe.h
deleted file mode 100644 (file)
index 71edf7e..0000000
--- a/source/pipe.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#ifndef MSP_IO_PIPE_H_
-#define MSP_IO_PIPE_H_
-
-#include "base.h"
-
-namespace Msp {
-namespace IO {
-
-class Pipe: public Base
-{
-private:
-       Handle handle[2];
-#ifdef WIN32
-       OVERLAPPED *overlapped;
-       Handle event;
-       unsigned buf_size;
-       char *buffer;
-       unsigned buf_avail;
-       char *buf_next;
-#endif
-
-public:
-       Pipe();
-       ~Pipe();
-
-       void close();
-
-       void set_block(bool);
-
-protected:
-       virtual unsigned do_write(const char *, unsigned);
-       virtual unsigned do_read(char *, unsigned);
-
-public:
-       virtual Handle get_event_handle();
-};
-
-} // namespace IO
-} // namespace Msp
-
-#endif

diff --git a/source/poll.cpp b/source/poll.cpp
deleted file mode 100644 (file)
index dce1912..0000000
--- a/source/poll.cpp
+++ /dev/null
@@ -1,212 +0,0 @@
-#include <errno.h>
-#include <msp/strings/formatter.h>
-#include <msp/time/units.h>
-#include "except.h"
-#include "base.h"
-#include "poll.h"
-
-namespace {
-
-using namespace Msp;
-using namespace Msp::IO;
-
-inline int sys_poll_event(PollEvent event)
-{
-       int result = 0;
-
-       if(event&~(P_INPUT|P_PRIO|P_OUTPUT))
-               throw InvalidParameterValue("Invalid poll events");
-
-#ifndef WIN32
-       if(event&P_INPUT)
-               result |= POLLIN;
-       if(event&P_PRIO)
-               result |= POLLPRI;
-       if(event&P_OUTPUT)
-               result |= POLLOUT;
-#endif
-
-       return result;
-}
-
-inline PollEvent poll_event_from_sys(int event)
-{
-       PollEvent result = P_NONE;
-
-#ifdef WIN32
-       // Stop the compiler from complaining about unused parameter
-       event = event;
-#else
-       if(event&POLLIN)
-               result = result|P_INPUT;
-       if(event&POLLPRI)
-               result = result|P_PRIO;
-       if(event&POLLOUT)
-               result = result|P_OUTPUT;
-       if(event&POLLERR)
-               result = result|P_ERROR;
-#endif
-
-       return result;
-}
-
-inline PollEvent do_poll(Base &obj, PollEvent pe, int timeout)
-{
-#ifdef WIN32
-       if(timeout<0)
-               timeout = INFINITE;
-
-       DWORD ret = WaitForSingleObject(obj.get_event_handle(), timeout);
-       if(ret==WAIT_OBJECT_0)
-               return pe;
-       else if(ret==WAIT_FAILED)
-               throw SystemError("Poll failed", GetLastError());
-
-       return P_NONE;
-#else
-       pollfd pfd = {obj.get_event_handle(), sys_poll_event(pe), 0};
-
-       int ret = ::poll(&pfd, 1, timeout);
-       if(ret==-1)
-       {
-               if(errno==EINTR)
-                       return P_NONE;
-               else
-                       throw SystemError("Poll failed", errno);
-       }
-
-       return poll_event_from_sys(pfd.revents);
-#endif
-}
-
-}
-
-namespace Msp {
-namespace IO {
-
-Poller::Poller():
-       pfd_dirty(false)
-{ }
-
-void Poller::set_object(Base &obj, PollEvent ev)
-{
-       // Verify that the object has an event handle
-       if(ev)
-               obj.get_event_handle();
-
-       SlotMap::iterator i = objects.find(&obj);
-       if(i!=objects.end())
-       {
-               if(ev)
-                       i->second.events = ev;
-               else
-                       objects.erase(i);
-
-               pfd_dirty = true;
-       }
-       else if(ev)
-       {
-#ifdef WIN32
-               if(objects.size()>=MAXIMUM_WAIT_OBJECTS)
-                       throw InvalidState("Maximum number of wait objects reached");
-#endif
-               objects.insert(SlotMap::value_type(&obj, Slot(&obj, ev)));
-
-               pfd_dirty = true;
-       }
-}
-
-int Poller::poll()
-{
-       return do_poll(-1);
-}
-
-int Poller::poll(const Time::TimeDelta &timeout)
-{
-       if(timeout<Time::zero)
-               throw InvalidParameterValue("Invalid timeout");
-
-       return do_poll(static_cast<int>(timeout/Time::msec));
-}
-
-void Poller::rebuild_pfd()
-{
-       pfd.clear();
-
-       pollfd p;
-
-       for(SlotMap::iterator i=objects.begin(); i!=objects.end(); ++i)
-       {
-               p.fd = i->second.object->get_event_handle();
-#ifndef WIN32
-               p.events = sys_poll_event(i->second.events);
-#endif
-               pfd.push_back(p);
-       }
-
-       pfd_dirty = false;
-}
-
-int Poller::do_poll(int timeout)
-{
-       if(pfd_dirty)
-               rebuild_pfd();
-
-       poll_result.clear();
-
-#ifdef WIN32
-       if(timeout<0)
-               timeout = INFINITE;
-
-       DWORD ret = WaitForMultipleObjects(pfd.size(), &pfd.front().fd, false, timeout);
-       if(/*ret>=WAIT_OBJECT_0 &&*/ ret<WAIT_OBJECT_0+pfd.size())
-       {
-               SlotMap::iterator i = objects.begin();
-               advance(i, ret-WAIT_OBJECT_0);
-               poll_result.push_back(Slot(i->second.object, i->second.events));
-
-               return 1;
-       }
-       else if(ret==WAIT_FAILED)
-               throw SystemError("Poll failed", GetLastError());
-
-       return 0;
-#else
-       int ret = ::poll(&pfd.front(), pfd.size(), timeout);
-       if(ret==-1)
-       {
-               if(errno==EINTR)
-                       return 0;
-               else
-                       throw SystemError("Poll failed", errno);
-       }
-
-       int n = ret;
-       SlotMap::iterator j = objects.begin();
-       for(std::vector<pollfd>::iterator i=pfd.begin(); (i!=pfd.end() && n>0); ++i,++j)
-               if(i->revents)
-               {
-                       poll_result.push_back(Slot(j->second.object, poll_event_from_sys(i->revents)));
-                       --n;
-               }
-
-       return ret;
-#endif
-}
-
-
-PollEvent poll(Base &obj, PollEvent pe)
-{
-       return do_poll(obj, pe, -1);
-}
-
-PollEvent poll(Base &obj, PollEvent pe, const Time::TimeDelta &timeout)
-{
-       if(timeout<Time::zero)
-               throw InvalidParameterValue("Invalid timeout");
-
-       return do_poll(obj, pe, static_cast<int>(timeout/Time::msec));
-}
-
-} // namespace IO
-} // namespace Msp

diff --git a/source/poll.h b/source/poll.h
deleted file mode 100644 (file)
index 6367d8f..0000000
--- a/source/poll.h
+++ /dev/null
@@ -1,82 +0,0 @@
-#ifndef MSP_IO_POLL_H_
-#define MSP_IO_POLL_H_
-
-#ifndef WIN32
-#include <poll.h>
-#endif
-#include <list>
-#include <map>
-#include <vector>
-#include <msp/time/timedelta.h>
-#include "types.h"
-
-namespace Msp {
-namespace IO {
-
-class Base;
-
-enum PollEvent
-{
-       P_NONE = 0,
-       P_INPUT = 1,
-       P_PRIO = 2,
-       P_OUTPUT = 4,
-       P_ERROR = 8
-};
-
-inline PollEvent operator|(PollEvent e, PollEvent f)
-{ return PollEvent(static_cast<int>(e)|static_cast<int>(f)); }
-
-inline PollEvent operator&(PollEvent e, PollEvent f)
-{ return PollEvent(static_cast<int>(e)&static_cast<int>(f)); }
-
-inline PollEvent operator~(PollEvent e)
-{ return PollEvent(~static_cast<int>(e)); }
-
-
-class Poller
-{
-public:
-       struct Slot
-       {
-               Base *object;
-               PollEvent events;
-
-               Slot(Base *o, PollEvent e): object(o), events(e) { }
-       };
-
-       typedef std::list<Slot> SlotSeq;
-private:
-       typedef std::map<Base *, Slot> SlotMap;
-
-#ifdef WIN32
-       struct pollfd
-       {
-               Handle fd;
-       };
-#endif
-
-       SlotMap objects;
-       std::vector<pollfd> pfd;
-       bool pfd_dirty;
-       SlotSeq poll_result;
-
-       void rebuild_pfd();
-       int do_poll(int);
-
-public:
-       Poller();
-
-       void set_object(Base &, PollEvent);
-       int poll();
-       int poll(const Time::TimeDelta &);
-       const SlotSeq &get_result() const { return poll_result; }
-};
-
-PollEvent poll(Base &, PollEvent);
-PollEvent poll(Base &, PollEvent, const Time::TimeDelta &);
-
-} // namespace IO
-} // namespace Msp
-
-#endif

diff --git a/source/print.h b/source/print.h
deleted file mode 100644 (file)
index 65744cb..0000000
--- a/source/print.h
+++ /dev/null
@@ -1,66 +0,0 @@
-#ifndef MSP_IO_PRINT_H_
-#define MSP_IO_PRINT_H_
-
-#include <msp/strings/formatter.h>
-#include "base.h"
-#include "console.h"
-
-namespace Msp {
-namespace IO {
-
-/**
-Writes a string to an I/O object.  Same as o.write(f).  Provided for
-completeness with the other print functions.
-*/
-inline unsigned print(Base &o, const std::string &f)
-{ return o.write(f); }
-
-template<typename A1>
-inline unsigned print(Base &o, const std::string &f, A1 a1)
-{ return print(o, format(f, a1)); }
-
-template<typename A1, typename A2>
-inline unsigned print(Base &o, const std::string &f, A1 a1, A2 a2)
-{ return print(o, format(f, a1, a2)); }
-
-template<typename A1, typename A2, typename A3>
-inline unsigned print(Base &o, const std::string &f, A1 a1, A2 a2, A3 a3)
-{ return print(o, format(f, a1, a2, a3)); }
-
-template<typename A1, typename A2, typename A3, typename A4>
-inline unsigned print(Base &o, const std::string &f, A1 a1, A2 a2, A3 a3, A4 a4)
-{ return print(o, format(f, a1, a2, a3, a4)); }
-
-template<typename A1, typename A2, typename A3, typename A4, typename A5>
-inline unsigned print(Base &o, const std::string &f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
-{ return print(o, format(f, a1, a2, a3, a4, a5)); }
-
-/* The following functions print to console */
-
-inline unsigned print(const std::string &f)
-{ return print(cout, f); }
-
-template<typename A1>
-inline unsigned print(const std::string &f, A1 a1)
-{ return print(cout, f, a1); }
-
-template<typename A1, typename A2>
-inline unsigned print(const std::string &f, A1 a1, A2 a2)
-{ return print(cout, f, a1, a2); }
-
-template<typename A1, typename A2, typename A3>
-inline unsigned print(const std::string &f, A1 a1, A2 a2, A3 a3)
-{ return print(cout, f, a1, a2, a3); }
-
-template<typename A1, typename A2, typename A3, typename A4>
-inline unsigned print(const std::string &f, A1 a1, A2 a2, A3 a3, A4 a4)
-{ return print(cout, f, a1, a2, a3, a4); }
-
-template<typename A1, typename A2, typename A3, typename A4, typename A5>
-inline unsigned print(const std::string &f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
-{ return print(cout, f, a1, a2, a3, a4, a5); }
-
-} // namespace IO
-} // namespace Msp
-
-#endif

diff --git a/source/seek.cpp b/source/seek.cpp
deleted file mode 100644 (file)
index b10c5a0..0000000
--- a/source/seek.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#ifdef WIN32
-#include <windows.h>
-#endif
-#include "except.h"
-#include "seek.h"
-
-namespace Msp {
-namespace IO {
-
-int sys_seek_type(SeekType st)
-{
-#ifdef WIN32
-       if(st==S_BEG)
-               return FILE_BEGIN;
-       else if(st==S_CUR)
-               return FILE_CURRENT;
-       else if(st==S_END)
-               return FILE_END;
-#else
-       if(st==S_BEG)
-               return SEEK_SET;
-       else if(st==S_CUR)
-               return SEEK_CUR;
-       else if(st==S_END)
-               return SEEK_END;
-#endif
-
-       throw InvalidParameterValue("Invalid seek type");
-}
-
-} // namespace IO
-} // namespace Msp

diff --git a/source/seek.h b/source/seek.h
deleted file mode 100644 (file)
index 3c6c331..0000000
--- a/source/seek.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#ifndef MSP_IO_SEEK_H_
-#define MSP_IO_SEEK_H_
-
-namespace Msp {
-namespace IO {
-
-enum SeekType
-{
-       S_BEG,
-       S_CUR,
-       S_END
-};
-
-extern int sys_seek_type(SeekType);
-
-} // namespace IO
-} // namespace Msp
-
-#endif

diff --git a/source/serial.cpp b/source/serial.cpp
deleted file mode 100644 (file)
index ec6a198..0000000
--- a/source/serial.cpp
+++ /dev/null
@@ -1,340 +0,0 @@
-#ifdef WIN32
-#include <windows.h>
-#else
-#include <termios.h>
-#include <fcntl.h>
-#include <errno.h>
-#endif
-#include <msp/strings/formatter.h>
-#include "except.h"
-#include "serial.h"
-
-using namespace std;
-
-namespace {
-
-using namespace Msp;
-using namespace Msp::IO;
-
-#ifdef WIN32
-typedef DCB DeviceState;
-#else
-typedef termios DeviceState;
-#endif
-
-void get_state(Handle handle, DeviceState &state)
-{
-#ifdef WIN32
-       GetCommState(handle, &state);
-#else
-       tcgetattr(handle, &state);
-#endif
-}
-
-void set_state(Handle handle, DeviceState &state)
-{
-#ifdef WIN32
-       if(SetCommState(handle, &state)==0)
-               throw SystemError("Cannot set serial port parameters", GetLastError());
-#else
-       if(tcsetattr(handle, TCSADRAIN, &state)==-1)
-               throw SystemError("Cannot set serial port parameters", errno);
-#endif
-}
-
-void set_baud_rate(DeviceState &state, unsigned baud)
-{
-#ifdef WIN32
-       state.BaudRate = baud;
-#else
-       speed_t speed;
-       switch(baud)
-       {
-       case 0:      speed = B0; break;
-       case 50:     speed = B50; break;
-       case 75:     speed = B75; break;
-       case 110:    speed = B110; break;
-       case 134:    speed = B134; break;
-       case 150:    speed = B150; break;
-       case 200:    speed = B200; break;
-       case 300:    speed = B300; break;
-       case 600:    speed = B600; break;
-       case 1200:   speed = B1200; break;
-       case 1800:   speed = B1800; break;
-       case 2400:   speed = B2400; break;
-       case 4800:   speed = B4800; break;
-       case 9600:   speed = B9600; break;
-       case 19200:  speed = B19200; break;
-       case 38400:  speed = B38400; break;
-       case 57600:  speed = B57600; break;
-       case 115200: speed = B115200; break;
-       case 230400: speed = B230400; break;
-       default: throw InvalidParameterValue("Invalid baud rate");
-       }
-
-       cfsetospeed(&state, speed);
-       cfsetispeed(&state, speed);
-#endif
-}
-
-void set_data_bits(DeviceState &state, unsigned bits)
-{
-#ifdef WIN32
-       state.ByteSize = bits;
-#else
-       tcflag_t flag;
-       switch(bits)
-       {
-       case 5: flag = CS5; break;
-       case 6: flag = CS6; break;
-       case 7: flag = CS7; break;
-       case 8: flag = CS8; break;
-       default: throw InvalidParameterValue("Invalid data bit count");
-       }
-
-       state.c_cflag = (state.c_cflag&~CSIZE)|flag;
-#endif
-}
-
-void set_parity(DeviceState &state, Serial::Parity par)
-{
-#ifdef WIN32
-       switch(par)
-       {
-       case Serial::NONE: state.Parity = NOPARITY; break;
-       case Serial::EVEN: state.Parity = EVENPARITY; break;
-       case Serial::ODD:  state.Parity = ODDPARITY; break;
-       default: throw InvalidParameterValue("Invalid parity");
-       }
-#else
-       tcflag_t flag;
-       switch(par)
-       {
-       case Serial::NONE: flag = 0; break;
-       case Serial::EVEN: flag = PARENB; break;
-       case Serial::ODD:  flag = PARENB|PARODD; break;
-       default: throw InvalidParameterValue("Invalid parity");
-       }
-
-       state.c_cflag = (state.c_cflag&~(PARENB|PARODD))|flag;
-#endif
-}
-
-void set_stop_bits(DeviceState &state, unsigned bits)
-{
-#ifdef WIN32
-       switch(bits)
-       {
-       case 1: state.StopBits = ONESTOPBIT; break;
-       case 2: state.StopBits = TWOSTOPBITS; break;
-       default: throw InvalidParameterValue("Invalid stop bit count");
-       }
-#else
-       tcflag_t flag;
-       switch(bits)
-       {
-       case 1: flag = 0; break;
-       case 2: flag = CSTOPB; break;
-       default: throw InvalidParameterValue("Invalid stop bit count");
-       }
-
-       state.c_cflag = (state.c_cflag&~CSTOPB)|flag;
-#endif
-}
-
-}
-
-
-namespace Msp {
-namespace IO {
-
-Serial::Serial(const string &descr)
-{
-       string::size_type comma = descr.find(',');
-       string port = descr.substr(0, comma);
-
-#ifdef WIN32
-       port = "\\\\.\\"+port;
-
-       handle = CreateFile(port.c_str(), GENERIC_READ|GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
-       if(handle==INVALID_HANDLE_VALUE)
-               throw SystemError(format("Can't open serial port '%s'", port), GetLastError());
-       mode = M_READ|M_WRITE;
-
-       COMMTIMEOUTS timeouts;
-       timeouts.ReadIntervalTimeout = MAXDWORD;
-       timeouts.ReadTotalTimeoutMultiplier = MAXDWORD;
-       timeouts.ReadTotalTimeoutConstant = MAXDWORD-1;
-       timeouts.WriteTotalTimeoutMultiplier = 0;
-       timeouts.WriteTotalTimeoutConstant = 0;
-       SetCommTimeouts(handle, &timeouts);
-#else
-       if(port.compare(0, 5, "/dev/"))
-               port = "/dev/"+port;
-
-       handle = open(port.c_str(), O_RDWR);
-       if(handle==-1)
-               throw SystemError(format("Can't open serial port '%s'", port), errno);
-       mode = M_READ|M_WRITE;
-
-       termios t;
-       tcgetattr(handle, &t);
-       t.c_lflag &= ~(ECHO|ICANON);
-       t.c_oflag &= ~OPOST;
-       tcsetattr(handle, TCSADRAIN, &t);
-#endif
-
-       if(comma!=string::npos)
-       {
-               try
-               {
-                       set_parameters(descr.substr(comma+1));
-               }
-               catch(...)
-               {
-                       close();
-                       throw;
-               }
-       }
-
-       set_events(P_INPUT);
-}
-
-Serial::~Serial()
-{
-       close();
-}
-
-void Serial::close()
-{
-#ifdef WIN32
-       CloseHandle(handle);
-#else
-       ::close(handle);
-#endif
-}
-
-void Serial::set_block(bool b)
-{
-       if(b)
-               mode = mode|M_NONBLOCK;
-       else
-               mode = mode&~M_NONBLOCK;
-
-#ifndef WIN32
-       int flags = fcntl(handle, F_GETFD);
-       fcntl(handle, F_SETFL, (flags&O_NONBLOCK)|(b?0:O_NONBLOCK));
-#endif
-}
-
-void Serial::set_baud_rate(unsigned rate)
-{
-       DeviceState state;
-       get_state(handle, state);
-       ::set_baud_rate(state, rate);
-       set_state(handle, state);
-}
-
-void Serial::set_data_bits(unsigned bits)
-{
-       DeviceState state;
-       get_state(handle, state);
-       ::set_data_bits(state, bits);
-       set_state(handle, state);
-}
-
-void Serial::set_parity(Parity par)
-{
-       DeviceState state;
-       get_state(handle, state);
-       ::set_parity(state, par);
-       set_state(handle, state);
-}
-
-void Serial::set_stop_bits(unsigned bits)
-{
-       DeviceState state;
-       get_state(handle, state);
-       ::set_stop_bits(state, bits);
-       set_state(handle, state);
-}
-
-void Serial::set_parameters(const string &params)
-{
-       unsigned i;
-       for(i=0; i<params.size() && isdigit(params[i]); ++i) ;
-       if(i+4!=params.size() || params[i]!=',')
-               throw InvalidParameterValue("Invalid parameter string");
-       if(params[i+1]<'5' || params[i+1]>'8')
-               throw InvalidParameterValue("Invalid data bit count");
-       if(params[i+2]!='N' && params[i+2]!='E' && params[i+2]!='O')
-               throw InvalidParameterValue("Invalid parity");
-       if(params[i+3]!='1' && params[i+3]!='2')
-               throw InvalidParameterValue("Invalid stop bit count");
-
-       DeviceState state;
-       get_state(handle, state);
-       ::set_baud_rate(state, lexical_cast<unsigned>(params.substr(0, i)));
-       ::set_data_bits(state, params[i+1]-'0');
-       ::set_parity(state, (params[i+2]=='E' ? EVEN : params[i+2]=='O' ? ODD : NONE));
-       ::set_stop_bits(state, params[i+3]-'0');
-       set_state(handle, state);
-}
-
-unsigned Serial::do_write(const char *buf, unsigned size)
-{
-       if(size==0)
-               return 0;
-
-#ifdef WIN32
-       DWORD ret;
-       if(WriteFile(handle, buf, size, &ret, 0)==0)
-               throw SystemError("Writing to serial port failed", GetLastError());
-#else
-       int ret = ::write(handle, buf, size);
-       if(ret==-1)
-       {
-               if(errno==EAGAIN)
-                       return 0;
-               else
-                       throw SystemError("Writing to serial port failed", errno);
-       }
-#endif
-
-       return ret;
-}
-
-unsigned Serial::do_read(char *buf, unsigned size)
-{
-       if(size==0)
-               return 0;
-
-#ifdef WIN32
-       DWORD ret;
-       if(ReadFile(handle, buf, size, &ret, 0)==0)
-               throw SystemError("Reading from serial port failed", GetLastError());
-#else
-       int ret = ::read(handle, buf, size);
-       if(ret==-1)
-       {
-               if(errno==EAGAIN)
-                       return 0;
-               else
-                       throw SystemError("Reading from serial port failed", errno);
-       }
-#endif
-
-       return ret;
-}
-
-Handle Serial::get_event_handle()
-{
-#ifdef WIN32
-       throw Exception("Serial port events not supported on win32 yet");
-#else
-       return handle;
-#endif
-}
-
-} // namespace IO
-} // namespace Msp

diff --git a/source/serial.h b/source/serial.h
deleted file mode 100644 (file)
index 069789c..0000000
--- a/source/serial.h
+++ /dev/null
@@ -1,49 +0,0 @@
-#ifndef MSP_IO_SERIAL_H_
-#define MSP_IO_SERIAL_H_
-
-#include "base.h"
-
-namespace Msp {
-namespace IO {
-
-class Serial: public Base
-{
-public:
-       enum Parity
-       {
-               NONE,
-               EVEN,
-               ODD
-       };
-
-private:
-       Handle handle;
-
-public:
-       Serial(const std::string &);
-       virtual ~Serial();
-
-private:
-       void close();
-
-public:
-       virtual void set_block(bool);
-
-       void set_baud_rate(unsigned);
-       void set_data_bits(unsigned);
-       void set_parity(Parity);
-       void set_stop_bits(unsigned);
-       void set_parameters(const std::string &);
-
-private:
-       virtual unsigned do_write(const char *, unsigned);
-       virtual unsigned do_read(char *, unsigned);
-
-public:
-       virtual Handle get_event_handle();
-};
-
-} // namespace IO
-} // namespace Msp
-
-#endif

diff --git a/source/types.h b/source/types.h
deleted file mode 100644 (file)
index f18b7cb..0000000
--- a/source/types.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#ifndef MSP_IO_TYPES_H_
-#define MSP_IO_TYPES_H_
-
-#ifdef WIN32
-#include <windows.h>
-#endif
-
-namespace Msp {
-namespace IO {
-
-#ifdef WIN32
-typedef HANDLE Handle;
-#define MSP_IO_INVALID_HANDLE INVALID_HANDLE_VALUE
-#else
-typedef int Handle;
-#define MSP_IO_INVALID_HANDLE -1
-#endif
-
-} // namespace IO
-} // namespace Msp
-
-#endif

diff --git a/source/utils.cpp b/source/utils.cpp
deleted file mode 100644 (file)
index eee51cc..0000000
--- a/source/utils.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "base.h"
-#include "utils.h"
-
-namespace Msp {
-namespace IO {
-
-unsigned read_all(Base &obj, char *buf, unsigned size)
-{
-       unsigned pos = 0;
-       while(pos<size)
-               pos += obj.read(buf+pos, size-pos);
-
-       return pos;
-}
-
-} // namespace IO
-} // namespace Msp

diff --git a/source/utils.h b/source/utils.h
deleted file mode 100644 (file)
index 8d4f9dd..0000000
--- a/source/utils.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifndef MSP_IO_UTILS_H_
-#define MSP_IO_UTILS_H_
-
-namespace Msp {
-namespace IO {
-
-class Base;
-
-/** Reads data from an object.  Does not return until the requested amount of
-data is read, regardless of the blocking mode of the object.
-
-Note: If the data is not immediately available and the object is in non-blocking
-mode, this function effectively becomes a busyloop until it can get more
-data. */
-unsigned read_all(Base &, char *, unsigned);
-
-} // namespace IO
-} // namespace Msp
-
-#endif