/Users/paul/Documents/phlogo/core/Tokenizer.cpp

/*
 *  Tokenizer.cpp
 *
 *  Author: Paul Hamilton
 *      Date: 4 Jul 2011
 *
 */
#include "Tokenizer.h"
        
#include "Exceptions.h"
#include "Verbs.h"

#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_object.hpp>
#include <boost/lexical_cast.hpp>

using namespace std;
using namespace boost;

//#define DEBUG_SPIRIT

namespace phlogo {

namespace qi = spirit::qi;
namespace phoenix = phoenix;
namespace ascii = spirit::ascii;

struct verbs_ : qi::symbols<char, string>
{
        verbs_() {
        }

} verbs;

class binary_op;
class unary_op;
class sequence_op;
class nil {};

class logo_ast
{
public:

        typedef
                boost::variant<
                        nil // can't happen!
                  , std::string
                  , std::vector<logo_ast>
                  , boost::recursive_wrapper<logo_ast>
                  , boost::recursive_wrapper<binary_op>
                  , boost::recursive_wrapper<unary_op>
                >
        type;

        logo_ast()
          : expr(nil()) {}

        template <typename Expr>
        logo_ast(Expr const& expr)
          : expr(expr) {}

        logo_ast& operator+=(logo_ast const& rhs);
        logo_ast& operator-=(logo_ast const& rhs);
        logo_ast& operator*=(logo_ast const& rhs);
        logo_ast& operator/=(logo_ast const& rhs);
        
        logo_ast& operator%=(logo_ast const& rhs);

private:
        friend class ast_to_string;
        friend class ast_print;
        
        type expr;
};

class binary_op
{
public:
        binary_op(
                char op
          , logo_ast const& left
          , logo_ast const& right)
        : op(op), left(left), right(right) {}

private:
        friend class ast_to_string;
        friend class ast_print;

        char op;
        logo_ast left;
        logo_ast right;
};

class unary_op
{
public:
        unary_op(
                char op
          , logo_ast const& subject)
        : op(op), subject(subject) {}

private:
        friend class ast_to_string;
        friend class ast_print;
        
        char op;
        logo_ast subject;
};

logo_ast& logo_ast::operator+=(logo_ast const& rhs)
{
        expr = binary_op('+', expr, rhs);
        return *this;
}

logo_ast& logo_ast::operator-=(logo_ast const& rhs)
{
        expr = binary_op('-', expr, rhs);
        return *this;
}

logo_ast& logo_ast::operator*=(logo_ast const& rhs)
{
        expr = binary_op('*', expr, rhs);
        return *this;
}

logo_ast& logo_ast::operator/=(logo_ast const& rhs)
{
        expr = binary_op('/', expr, rhs);
        return *this;
}

logo_ast& logo_ast::operator%=(logo_ast const& rhs)
{
        try {
                std::vector<logo_ast> v = boost::get<std::vector<logo_ast> >(expr);
                v.push_back(rhs);
                expr = v;
        } catch (boost::bad_get x) {
                try {
                        boost::get<nil>(expr);
                        std::vector<logo_ast> v;
                        v.push_back(rhs);
                        expr = v;
                }
                catch (boost::bad_get x) {
                        // must be something else, how did we get to add a sequence to it!
                        throw;
                }
        }       
        return *this;
}

class ast_to_string
{
public:
        ast_to_string(std::stringstream *s) : _s(s) {}
        
        typedef void result_type;
        
        void operator()(nil) const {}
        void operator()(std::string s) const 
        { 
                *_s << s; 
        }
        void operator()(std::vector<logo_ast> v) const 
        { 
                bool empty = _s->tellp() == 0;
                if (!empty)
                        *_s << "( ";
                for (std::vector<logo_ast>::iterator i=v.begin(); i != v.end(); i++) {
                        if (i != v.begin())
                                *_s << " ";
                        boost::apply_visitor(*this, i->expr);
                }
                if (!empty)
                        *_s << " )";
        }
        
        void operator()(logo_ast const& ast) const
        {
                boost::apply_visitor(*this, ast.expr);
        }
        
        void operator()(binary_op const& expr) const
        {
                *_s << "$" << expr.op << " ";
                boost::apply_visitor(*this, expr.left.expr);
                *_s << " ";
                boost::apply_visitor(*this, expr.right.expr);
        }
        
        void operator()(unary_op const& expr) const
        {
                *_s << "$" << expr.op << " ";
                boost::apply_visitor(*this, expr.subject.expr);
        }

private:
        std::stringstream *_s;
};

std::ostream& operator << (std::ostream& out, logo_ast const& ast) {
        std::stringstream s;
        ast_to_string printer(&s);
        printer(ast);
        out << s.str();
        return out;
}

template <typename Iterator>
struct logosyntax : qi::grammar<Iterator, logo_ast(), qi::locals<string>, ascii::space_type>
{
        logosyntax() : logosyntax::base_type(sequence)
        {
                using namespace qi::labels;
                using qi::uint_;
                using qi::char_;
                using qi::on_error;
                using qi::rethrow;
                using qi::debug;
                using qi::digit;
                using qi::alpha;
                using qi::alnum;
                using qi::string;
                using qi::eol;
                using qi::skip;
                using qi::as_string;
                
                using spirit::lexeme;
                
                using phoenix::construct;
                using phoenix::val;

                sequence =
                        expression                                              [_val %= _1]
                        >> *(  
                                (expression                             [_val %= _1])
                        ) 
                        >> -(';' >> *( alnum ))
                        ;
                        
                expression = 
                        term                            [_val = _1]
                        >> *(  ('+' > term      [_val += _1])
                                 | ('-' > term  [_val -= _1])
                        )
                        ;

           term =
                        factor                  [_val = _1]
                        >> *(  ('*' > factor    [_val *= _1])
                                 | ('/' > factor        [_val /= _1])
                        )
                        ;

                factor =
                        tokenorsubexr           [_val = _1]   
                        |   ('-' > factor               [_val -= _1])
                        |   ('+' > factor               [_val += _1])
                        ;

                tokenorsubexr =
                        token                                   [_val = _1]   
                        | '(' 
                                >> expression                   [_val %= _1]
                                >> *(  
                                        (expression                     [_val %= _1])
                                )
                                >> ')'
                        ;

                token =
                        as_string[lexeme[(+(digit | string(".")))]]     [_val = _1]
                        | '\"' > as_string[lexeme[
                                +(alpha | digit | string("."))
                                ]]                                                                              [_val = _1]
                        | as_string[lexeme[
                                string(":") 
                > +(alpha | digit | string("."))
                                ]]                                                                              [_val = _1]
                        | verbs                                                                         [_val = _1]
                        | list                                                                          [_val = _1]
                        | array                                                                         [_val = _1]
                        ;
                        
                element = 
            verbs                               [_val = _1]
                        | as_string[lexeme[(+alpha)]]           [_val = _1]
                        | as_string[lexeme[(+digit)]]           [_val = _1]
            | '\"' > as_string[lexeme[
                +(alpha | digit | string("."))
                ]]                                                              [_val = _1]
                        | list                              [_val = _1]
                        | array                             [_val = _1]
                        ;
                        
                list =
                        (
                                string("[")                                     [_a = _1]
                                >> -(   
                                        element                                         [_a += _1]
                                        >> *( element                           [_a += "," + _1])       
                                )
                                >> string("]")                                  [_a += _1]
                        )                                                                       [_val = _a];

                array =
                        (
                                string("{")                                     [_a = _1]
                                >> -(   
                                        element                                         [_a += _1]
                                        >> *( element                           [_a += "," + _1])       
                                )
                                >> string("}")                                  [_a += _1]
                        )                                                                       [_val = _a];

                expression.name("expression");
                term.name("term");
                factor.name("factor");
                sequence.name("sequence");
                token.name("token");
                tokenorsubexr.name("tokenorsubexr");
                list.name("list");
                array.name("array");
                element.name("element");
                
                on_error<rethrow>
                (
                        sequence, 
                        std::cout << val("")
                );


#ifdef DEBUG_SPIRIT
                debug(sequence);
                debug(token);
                debug(tokenorsubexr);
                debug(list);
                debug(array);
                debug(element);
                debug(expression);
                debug(term);
                debug(factor);
#endif
        }

   qi::rule<Iterator, logo_ast(), qi::locals<string>, ascii::space_type> sequence, expression, term, factor, tokenorsubexr;
   qi::rule<Iterator, string(), qi::locals<string>, ascii::space_type> list, element, token, array;
};

string Tokenizer::tokenizeToString(const string &input) {

    using spirit::ascii::space;
    typedef std::string::const_iterator iterator_type;
    typedef logosyntax<iterator_type> logosyntax;

        // add to the symbol table...
        std::map<std::string, std::string>::const_iterator i = _verbs->getVerbTokenMap().begin();
        for (; i != _verbs->getVerbTokenMap().end(); i++)
                verbs.add(i->first, i->second);
        i = _verbs->getFuncTokenMap().begin();
        for (; i != _verbs->getFuncTokenMap().end(); i++)
                verbs.add(i->first, i->second);
        
        logosyntax syntax;
        std::string::const_iterator iter = input.begin();
    std::string::const_iterator end = input.end();
    logo_ast result;
        bool r;
    try {
                r = phrase_parse(iter, end, syntax, space, result);
        }
        catch (spirit::qi::expectation_failure<iterator_type> const& x) {
        
                try {
                        BOOST_THROW_EXCEPTION(
                                dont_know_how_exception() << 
                                        errinfo_tag(x.what_.tag) << 
                                        errinfo_value(std::string(x.first, x.last)) );
                }
                catch (bad_get const &x) {
                        r = false;
                }
        }
        if (!r || iter != end) {
                BOOST_THROW_EXCEPTION(
                          dont_know_how_exception() << 
                          errinfo_tag("expr") << 
                          errinfo_value(input) );
        }
        std::stringstream s;
        ast_to_string printer(&s);
        printer(result);
        
        return s.str();

}

}