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

/*
 *  ConstructorVerbs.cpp
 *
 *  Author: Paul Hamilton
 *      Date: 13 Jun 2011
 *
 */

#include "Verbs.h"

#include "Interpreter.h"
#include "World.h"
#include "Exceptions.h"
#include "List.h"
#include "Thing.h"
#include "Array.h"
#include "TokenStream.h"

#include <boost/lexical_cast.hpp>

using namespace std;
using namespace boost;

namespace phlogo {

void Verbs::catenateWords(TokenStream *ts, const char *sep) {

        string w = getWord(ts);
    
        if (ts->withinSubExpression()) {
                while (ts->hasMoreSubExpression()) {
                        w += (sep == 0 ? "" : sep) + getWord(ts);
                }
        }
        else {
        pThing thing;
                _itp->getNextThing(_world, ts, &thing);
                if (thing->isWord())
                        w += (sep == 0 ? "" : sep) + thing->getWord();
                else if (thing->isList()) {
                        for (tListArray::const_iterator i=thing->getList().begin(); i != thing->getList().end(); i++) {
                                if ((*i)->isWord())
                                        w += (sep == 0 ? "" : sep) + (*i)->getWord();
                                else
                                        w += (sep == 0 ? "" : sep) + (*i)->getList().str();
                        }
                }
        }
        
        // consumed all the data, return the verb.
        _world->allocResult()->set(w);
        
}

void Verbs::word(TokenStream *ts) {

        catenateWords(ts, 0);
        
}

void Verbs::sentence(TokenStream *ts) {

        catenateWords(ts, " ");
        
}

void Verbs::list(TokenStream *ts) {

        List list = _world->allocResult()->allocList();
        
        list.addString(getWord(ts));
        if (ts->withinSubExpression()) {
                while (ts->hasMoreSubExpression()) {
                        list.addString(getWord(ts));
                }
        }
        else {
                list.addString(getWord(ts));
        }

}


void Verbs::listput(TokenStream *ts, bool front) {

        pThing thing;
        _itp->getNextThing(_world, ts, &thing);
        
        pThing thing2;
        _itp->getNextThing(_world, ts, &thing2);
        if (!thing2->isList())
                BOOST_THROW_EXCEPTION( no_list_in_thing_exception() );
                
        // append to the start of the list
        if (front)
                thing2->getList().push_front(thing);
        else
                thing2->getList().push_back(thing);
        _world->setResult(thing2);

}


void Verbs::fput(TokenStream *ts) {

        listput(ts, true);

}

void Verbs::lput(TokenStream *ts) {

        listput(ts, false);

}

void Verbs::array(TokenStream *ts) {

        _world->allocResult()->allocArray(getLong(ts));

}

void Verbs::mdarray(TokenStream *ts) {

        pThing thing;
        _itp->getNextThing(_world, ts, &thing);
        if (!thing->isList())
                BOOST_THROW_EXCEPTION( no_list_in_thing_exception() );
        if (thing->getList().size() != 2)
                BOOST_THROW_EXCEPTION( incorrect_list_size_exception() );

        int xsize = boost::lexical_cast<int>(thing->getList().get(0)->getWord());
        int ysize = boost::lexical_cast<int>(thing->getList().get(1)->getWord());
        
        Array array = _world->allocResult()->allocArray(xsize);
        for (int x=0; x < xsize; x++) {
                pThing thing(new Thing());
                thing->allocArray(ysize);
                array.set(x, thing);
        }
}

void Verbs::listtoarray(TokenStream *ts) {

        pThing thing;
        _itp->getNextThing(_world, ts, &thing);
        if (!thing->isList())
                BOOST_THROW_EXCEPTION( no_list_in_thing_exception() );
        _world->allocResult()->allocArray(*thing->getList().getVector());

}

void Verbs::arraytolist(TokenStream *ts) {

        pThing thing;
        _itp->getNextThing(_world, ts, &thing);
        if (!thing->isArray())
                BOOST_THROW_EXCEPTION( no_array_in_thing_exception() );

        _world->allocResult()->allocList(*thing->getArray().getVector());

}

void Verbs::combine(TokenStream *ts) {

        pThing thing;
        _itp->getNextThing(_world, ts, &thing);

        pThing thing2;
        _itp->getNextThing(_world, ts, &thing2);
                
        if (thing2->isList()) {
                thing2->getList().push_front(thing);
                _world->setResult(thing2);
        }
        else {
                string w = thing->getWord() + thing2->getWord();
                _world->allocResult()->set(w);
        }

}

void Verbs::reverse(TokenStream *ts) {

        pThing thing;
        _itp->getNextThing(_world, ts, &thing);
        if (!thing->isList())
                BOOST_THROW_EXCEPTION( no_list_in_thing_exception() );

        List l2 = _world->allocResult()->allocList();
        for (tListArray::reverse_iterator i=thing->getList().rbegin(); 
                        i != thing->getList().rend(); i++)
                l2.add(*i);

}

int Verbs::gSymbol = 1;

void Verbs::gensym(TokenStream *ts) {

        _world->allocResult()->set("g" + boost::lexical_cast<string>(gSymbol));
        gSymbol++;      

}

}