csvparser.cpp

#include "csvparser.h"
#include <assert.h>
#include <string.h>
#include "csvbase.h"

#include <boost/variant.hpp>

//#define DEBUG

#ifdef DEBUG
 #include <stdio.h>
 #include <typeinfo>
#endif

namespace csvFSM {

// States
struct Start {};
struct ReadSkipPre {};
struct ReadQuoted {};
struct ReadQuotedCheckEscape {};
struct ReadQuotedSkipPost {};
struct ReadUnquoted {};
struct ReadUnquotedWhitespace { 
 ReadUnquotedWhitespace(unsigned char value) : value(1,value) {}
 std::string value;
};
struct ReadError {
 ReadError(const char *type) : type(type) {} // i.e. for static strings
 const char *type;
};
typedef boost::variant<Start,
 ReadSkipPre,
 ReadQuoted,
 ReadQuotedCheckEscape,
 ReadQuotedSkipPost,
 ReadUnquoted,
 ReadUnquotedWhitespace,
 ReadError> States;

// Events
struct Echar { // and fallback
 Echar(unsigned char value) : value(value) {}
 unsigned char value;
};
struct Ewhitespace : Echar { 
 Ewhitespace(unsigned char value) : Echar(value) {}
};
struct Eqchar : Echar {
 Eqchar(unsigned char value) : Echar(value) {}
};
struct Esep : Echar {
 Esep(unsigned char value) : Echar(value) {}
};
struct Enewline : Echar {
 Enewline(unsigned char value) : Echar(value) {}
};

#define TTS(S,E,Snew,code) bool on(States &self,S &s,const E &e) { code; self=Snew; return true; }
struct Trans {
 Trans(csv_builder &out) : out(out) {}

 /* Start eps { begin_row } ReadSkipPre */
 TTS(Start, Eqchar, ReadQuoted(), { out.begin_row(); });
 TTS(Start, Esep, ReadSkipPre(), { out.begin_row(); next_cell(false); });
 TTS(Start, Enewline, self, { out.begin_row(); out.end_row(); });
 TTS(Start, Ewhitespace, ReadSkipPre(), { out.begin_row(); });
 TTS(Start, Echar, ReadUnquoted(), { out.begin_row(); add(e); });

 /*
 template <typename State>
 TTS(State, Enewline, Start(), { ("Esep")(); out.end_row(); }); // on(self[_copy],s,Esep(e.value));
 */

 TTS(ReadSkipPre, Eqchar, ReadQuoted(), {});
 TTS(ReadSkipPre, Esep, self, { next_cell(false); });
 TTS(ReadSkipPre, Enewline, Start(), { next_cell(false); out.end_row(); });
 TTS(ReadSkipPre, Ewhitespace, self, {});
 TTS(ReadSkipPre, Echar, ReadUnquoted(), { add(e); });

 TTS(ReadQuoted, Eqchar, ReadQuotedCheckEscape(), {});
 TTS(ReadQuoted, Esep, self, { add(e); });
// TTS(ReadQuoted, Enewline, self, { add(e); });
// TTS(ReadQuoted, Ewhitespace, self, { add(e); });
 TTS(ReadQuoted, Echar, self, { add(e); });

 TTS(ReadQuotedCheckEscape, Eqchar, ReadQuoted(), { add(e); });
 TTS(ReadQuotedCheckEscape, Esep, ReadSkipPre(), { next_cell(); });
 TTS(ReadQuotedCheckEscape, Enewline, Start(), { next_cell(); out.end_row(); });
 TTS(ReadQuotedCheckEscape, Ewhitespace, ReadQuotedSkipPost(), {});
 TTS(ReadQuotedCheckEscape, Echar, ReadError("char after possible endquote"), { return false; });

// TTS(ReadQuotedSkipPost, Eqchar, ReadError("quote after endquote"), { return false; });
 TTS(ReadQuotedSkipPost, Esep, ReadSkipPre(), { next_cell(); });
 TTS(ReadQuotedSkipPost, Enewline, Start(), { next_cell(); out.end_row(); });
 TTS(ReadQuotedSkipPost, Ewhitespace, self, {});
 TTS(ReadQuotedSkipPost, Echar, ReadError("char after endquote"), { return false; });

 TTS(ReadUnquoted, Eqchar, ReadError("unexpected quote in unquoted string"), { return false; });
 TTS(ReadUnquoted, Esep, ReadSkipPre(), { next_cell(); });
 TTS(ReadUnquoted, Enewline, Start(), { next_cell(); out.end_row(); });
 TTS(ReadUnquoted, Ewhitespace, ReadUnquotedWhitespace(e.value), {});
 TTS(ReadUnquoted, Echar, self, { add(e); });

 TTS(ReadUnquotedWhitespace, Eqchar, ReadError("unexpected quote after unquoted string"), { return false; });
 TTS(ReadUnquotedWhitespace, Esep, ReadSkipPre(), { cell.append(s.value); next_cell(); });
 TTS(ReadUnquotedWhitespace, Enewline, Start(), { cell.append(s.value); next_cell(); out.end_row(); });
 TTS(ReadUnquotedWhitespace, Ewhitespace, self, { s.value.push_back(e.value); });
 TTS(ReadUnquotedWhitespace, Echar, ReadUnquoted(), { cell.append(s.value); add(e); });

 TTS(ReadError, Echar, self, { return false; });

private:
 inline void add(const Echar &e) { cell.push_back(e.value); }
 inline void next_cell(bool has_content=true) {
 if (has_content) {
 out.cell(cell.c_str(),cell.size());
 } else {
 assert(cell.empty());
 out.cell(NULL,0);
 }
 cell.clear();
 }
private:
 csv_builder &out;
 std::string cell;
};

namespace detail {
 template <class StateVariant,class Event,class Transitions>
 struct NextState : boost::static_visitor<bool> {
 NextState(StateVariant &v,const Event &e,Transitions &t) : v(v),e(e),t(t) {}

 template <class State>
 bool operator()(State &s) const {
#ifdef DEBUG
 printf("%s %c\n",typeid(State).name(),e.value);
#endif
 return t.on(v,s,e);
 }

// bool operator()(...) const { return false; }
 private:
 StateVariant &v;
 const Event &e;
 Transitions &t;
 };
} // namespace detail

#ifdef CPP11
template <class Transitions=Trans,class StateVariant,class Event>
bool next(StateVariant &state,Event &&event,Transitions &&trans=Transitions()) {
 return boost::apply_visitor(detail::NextState<StateVariant,Event,Transitions>(state,std::forward<Event>(event),std::forward<Transitions>(trans)),state);
}
#else
template <class Transitions,class StateVariant,class Event>
bool next(StateVariant &state,const Event &event,const Transitions &trans=Transitions()) {
 return boost::apply_visitor(detail::NextState<StateVariant,Event,Transitions>(state,event,trans),state);
}
template <class Transitions,class StateVariant,class Event>
bool next(StateVariant &state,const Event &event,Transitions &trans) {
 return boost::apply_visitor(detail::NextState<StateVariant,Event,Transitions>(state,event,trans),state);
}
#endif

} // namespace csvFSM

// TODO?
bool csvparser::operator()(const std::string &line) // {{{
{
 const char *buf=line.c_str();
 return (operator())(buf,line.size());
}
// }}}

bool csvparser::operator()(const char *&buf,int len) // {{{
{
 csvFSM::States state;
 csvFSM::Trans trans(out);
 while (len>0) {
 bool run=true;
 if (*buf==qchar) {
 run=csvFSM::next(state,csvFSM::Eqchar(*buf),trans);
 } else if (*buf==sep) {
 run=csvFSM::next(state,csvFSM::Esep(*buf),trans);
 } else if (*buf==' ') { // TODO? more (but DO NOT collide with sep=='\t')
 run=csvFSM::next(state,csvFSM::Ewhitespace(*buf),trans);
 } else if (*buf=='\n') {
 run=csvFSM::next(state,csvFSM::Enewline(*buf),trans);
 } else {
 run=csvFSM::next(state,csvFSM::Echar(*buf),trans);
 }
 if (!run) {
 csvFSM::ReadError *err=boost::get<csvFSM::ReadError>(&state);
 if (err) {
#ifdef DEBUG
 fprintf(stderr,"csv parse error: %s\n",err->type);
#endif
 errmsg=err->type;
 }
 return true;
 }
 buf++;
 len--;
 }
 return false;
}
// }}}