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

/*
 *  Verbs.cpp
 *
 *  Author: Paul Hamilton
 *      Date: 6 Jun 2011
 *
 */

#include "Verbs.h"

#include "Func.h"
#include "Scope.h"
#include "Exceptions.h"
#include "List.h"
#include "ListArrayParser.h"
#include "StringTokenStream.h"
#include "Interpreter.h"
#include "Thing.h"
#include "World.h"

#include <boost/lexical_cast.hpp>

using namespace std;
using namespace boost;

namespace phlogo {

Verbs::Verbs(Interpreter *itp, World *world) {

        _itp = itp;
        _world = world;
        
        // initialise all of the verbs we know about.
        addMap("print", "$1.1", &Verbs::print);
        addMap("pr", "$1.1", &Verbs::print);
        addMap("+", "$+", &Verbs::add);
        addMap("-", "$-", &Verbs::sub);
        addMap("*", "$*", &Verbs::mul);
        addMap("/", "$/", &Verbs::div);
        addMap("clearscreen", "$1.2", &Verbs::clearscreen);
        addMap("cs", "$1.2", &Verbs::clearscreen);
        addMap("make", "$1.3", &Verbs::make);
        addMap("thing", "$1.4", &Verbs::thing);
        addMap("output", "$1.5", &Verbs::output);
    
        addMap("test", "$1.6", &Verbs::test);
        addMap("testsuite", "$1.7", &Verbs::testsuite);
                
        addMap("load", "$1.8", &Verbs::load);
    
        addMap("word", "$2.1", &Verbs::word);
        addMap("list", "$2.2", &Verbs::list);
        addMap("sentence", "$2.3", &Verbs::sentence);
        addMap("se", "$2.4", &Verbs::sentence);
        addMap("fput", "$2.5", &Verbs::fput);
        addMap("lput", "$2.6", &Verbs::lput);
        addMap("array", "$2.7", &Verbs::array);
        addMap("mdarray", "$2.8", &Verbs::mdarray);
        addMap("listtoarray", "$2.9", &Verbs::listtoarray);
        addMap("arraytolist", "$2.10", &Verbs::arraytolist);
        addMap("combine", "$2.11", &Verbs::combine);
        addMap("reverse", "$2.12", &Verbs::reverse);
        addMap("gensym", "$2.13", &Verbs::gensym);

        addMap("first", "$3.1", &Verbs::first);
        addMap("firsts", "$3.2", &Verbs::firsts);
        addMap("last", "$3.3", &Verbs::last);
        addMap("butfirst", "$3.4", &Verbs::butfirst);
        addMap("bf", "$3.4", &Verbs::butfirst);
        addMap("butfirsts", "$3.5", &Verbs::butfirsts);
        addMap("bfs", "$3.5", &Verbs::butfirsts);
        addMap("butlast", "$3.6", &Verbs::butlast);
        addMap("bl", "$3.6", &Verbs::butlast);
        addMap("item", "$3.7", &Verbs::item);
        addMap("mditem", "$3.8", &Verbs::mditem);
        addMap("pick", "$3.9", &Verbs::pick);
        addMap("remove", "$3.10", &Verbs::remove);
        addMap("remdup", "$3.11", &Verbs::remdup);
        addMap("quoted", "$3.12", &Verbs::quoted);
        
        addMap("setitem", "$4.1", &Verbs::setitem);
        addMap("mdsetitem", "$4.2", &Verbs::mdsetitem);
        addMap("setfirst", "$4.3", &Verbs::setfirst);
        addMap("setbf", "$4.4", &Verbs::setbf);
        addMap("push", "$4.5", &Verbs::push);
        addMap("pop", "$4.6", &Verbs::pop);
        addMap("queue", "$4.7", &Verbs::queue);
        addMap("dequeue", "$4.8", &Verbs::dequeue);

        addMap("wordp", "$6.1", &Verbs::wordp);
        addMap("listp", "$6.2", &Verbs::listp);
        addMap("arrayp", "$6.3", &Verbs::arrayp);
        addMap("emptyp", "$6.4", &Verbs::emptyp);
        addMap("equalp", "$6.5", &Verbs::equalp);
        addMap("notequalp", "$6.6", &Verbs::notequalp);
        addMap("beforep", "$6.7", &Verbs::beforep);
        addMap("eq", "$6.8", &Verbs::eq);
        addMap("memberp", "$6.9", &Verbs::memberp);
        addMap("substringp", "$6.10", &Verbs::substringp);
        addMap("numberp", "$6.11", &Verbs::numberp);
    
        addMap("count", "$7.1", &Verbs::count);
        addMap("ascii", "$7.2", &Verbs::ascii);
        addMap("rawascii", "$7.2", &Verbs::ascii);
        addMap("char", "$7.3", &Verbs::ch);
        addMap("member", "$7.4", &Verbs::member);
        addMap("lowercase", "$7.5", &Verbs::lowercase);
        addMap("uppercase", "$7.6", &Verbs::uppercase);

        addMap("sum", "$8.1", &Verbs::sum);
        addMap("difference", "$8.2", &Verbs::difference);
        addMap("minus", "$8.3", &Verbs::minus);
        addMap("product", "$8.4", &Verbs::product);
        addMap("quotient", "$8.5", &Verbs::quotient);
        addMap("remainder", "$8.6", &Verbs::remainder);
        addMap("modulo", "$8.6", &Verbs::remainder);
        addMap("int", "$8.7", &Verbs::integer);
        addMap("round", "$8.8", &Verbs::round);
        addMap("sqrt", "$8.9", &Verbs::sqrt);
        addMap("power", "$8.10", &Verbs::power);
        addMap("exp", "$8.11", &Verbs::exp);
        addMap("log10", "$8.12", &Verbs::log10);
        addMap("ln", "$8.13", &Verbs::ln);
        addMap("sin", "$8.14", &Verbs::sin);
        addMap("radsin", "$8.15", &Verbs::radsin);
        addMap("cos", "$8.16", &Verbs::cos);
        addMap("radcos", "$8.17", &Verbs::radcos);
        addMap("arctan", "$8.18", &Verbs::arctan);
        addMap("radarctan", "$8.19", &Verbs::radarctan);
        addMap("iseq", "$8.20", &Verbs::iseq);
        addMap("rseq", "$8.21", &Verbs::rseq);

        addMap("lessp", "$9.1", &Verbs::lessp);
        addMap("greaterp", "$9.2", &Verbs::greaterp);
        addMap("lessequalp", "$9.3", &Verbs::lessequalp);
        addMap("greaterequalp", "$9.4", &Verbs::greaterequalp);
    
    srand(time(NULL));
        
    addMap("random", "$10.1", &Verbs::random);
        addMap("rerandom", "$10.2", &Verbs::rerandom);

        addMap("form", "$11.1", &Verbs::form);
    
        addMap("bitand", "$12.1", &Verbs::bitAnd);
        addMap("bitor", "$12.2", &Verbs::bitOr);
        addMap("bitxor", "$12.3", &Verbs::bitxor);
        addMap("bitnot", "$12.4", &Verbs::bitnot);
        addMap("ashift", "$12.5", &Verbs::lshift);
        addMap("lshift", "$12.5", &Verbs::lshift);

        addMap("and", "$13.1", &Verbs::And);
        addMap("or", "$13.2", &Verbs::Or);
        addMap("not", "$13.3", &Verbs::Not);

        addMap("contents", "$14.1", &Verbs::contents);
        addMap("procedures", "$14.2", &Verbs::procedures);
        addMap("primitives", "$14.3", &Verbs::primitives);
        addMap("names", "$14.4", &Verbs::names);
    
        addMap("erase", "$14.5", &Verbs::erase);
        addMap("erall", "$14.6", &Verbs::erall);
        addMap("erps", "$14.7", &Verbs::erps);
        addMap("erns", "$14.8", &Verbs::erns);
        addMap("ern", "$14.9", &Verbs::ern);

        addMap("procedurep", "$14.10", &Verbs::procedurep);
        addMap("definedp", "$14.10", &Verbs::procedurep);
        addMap("primitivep", "$14.11", &Verbs::primitivep);
        addMap("namep", "$14.12", &Verbs::namep);
   
        addMap("fd", "$5.1", &Verbs::fd);
        addMap("forward", "$5.1", &Verbs::fd);
        addMap("bk", "$5.2", &Verbs::bk);
        addMap("back", "$5.2", &Verbs::bk);
        addMap("lt", "$5.3", &Verbs::lt);
        addMap("left", "$5.3", &Verbs::lt);
        addMap("rt", "$5.4", &Verbs::rt);
        addMap("right", "$5.4", &Verbs::rt);
        addMap("repeat", "$5.5", &Verbs::repeat);
        addMap("pu", "$5.6", &Verbs::penup);
        addMap("penup", "$5.6", &Verbs::penup);
        addMap("pd", "$5.7", &Verbs::pendown);
        addMap("pendown", "$5.7", &Verbs::pendown);
    
        addMap("setpos", "$5.8", &Verbs::setpos);
        addMap("setxy", "$5.9", &Verbs::setxy);
        addMap("setx", "$5.10", &Verbs::setx);
        addMap("sety", "$5.11", &Verbs::sety);
        addMap("setheading", "$5.12", &Verbs::setheading);
        addMap("home", "$5.13", &Verbs::home);

        addMap("pos", "$5.14", &Verbs::pos);
        addMap("xcor", "$5.15", &Verbs::xcor);
        addMap("ycor", "$5.16", &Verbs::ycor);
        addMap("heading", "$5.17", &Verbs::heading);
        addMap("towards", "$5.18", &Verbs::towards);
    
}

void Verbs::addMap(const string &verb, const string &token, pVerb func) {
        _verbtokenmap[verb] = token;
        _map[token] = func;
}

long Verbs::getLong(TokenStream *ts) {
    
    pThing thing;
    _itp->getNextThing(_world, ts, &thing);
    return thing->asLong();
    
}

double Verbs::getDouble(TokenStream *ts) {
    
    pThing thing;
    _itp->getNextThing(_world, ts, &thing);
    return thing->asDouble();
    
}

double Verbs::getNum(TokenStream *ts, bool *isdouble) {
    
    pThing thing;
    _itp->getNextThing(_world, ts, &thing);
    
    try {
        long x = thing->asLong();
        *isdouble = false;
        return x;
    }
    catch (bad_cast &e) {
        double x = thing->asDouble();
        *isdouble = true;
        return x;
    }
    
}
    
string Verbs::getWord(TokenStream *ts) {
    
    pThing thing;
    _itp->getNextThing(_world, ts, &thing);
    if (!thing->isWord())
        BOOST_THROW_EXCEPTION( no_word_in_thing_exception() );
    
    return thing->getWord();
}
    
void Verbs::run(TokenStream *ts) {

        StringTokenStream *sts = static_cast<StringTokenStream *>(ts);
        
        string name = sts->nextWord();
        map<string, pVerb>::iterator i = _map.find(name);
        if (i != _map.end()) {
                try {
                        (*i).second(this, sts);
                }
                catch( dont_know_how_exception & x ) {
                        string *verb=get_error_info<errinfo_curr_verb>(x);
                        if (!verb)
                                x << errinfo_curr_verb(name);
                        throw;
                }
        }
        else {
                // second chance, we see if there is a function that has this name.
                Func *func = getFunction(name);
                if (func == 0) {
                        BOOST_THROW_EXCEPTION( dont_know_how_exception() <<
                          errinfo_curr_verb(name) <<
                          errinfo_bad_tokens(sts->remain()) );
                }
                else {
                        // this scope is for local vars of the functions.
                        Scope scope(_world);
                        func->execute(_itp, _world, sts);
                }
        }
}

Func *Verbs::createFunction(const string &name, const string &args) {

        map<string, string>::iterator i = _functokenmap.find(name);
        if (i != _functokenmap.end()) {
                BOOST_THROW_EXCEPTION(
                        func_already_exists_exception() << errinfo_curr_verb(name) );
        }
        else {
                shared_ptr<Func> func(new Func(args));
                string id = "#" + lexical_cast<string>(_functokenmap.size());
                _funcs[id] = func;
                _functokenmap[name] = id;
                return func.get();
        }
        
}

Func *Verbs::getFunction(const string &name) {
        map<string, shared_ptr<Func> >::iterator i = _funcs.find(name);
        return i != _funcs.end() ? i->second.get() : 0;
}

void Verbs::removeFunction(const std::string &name) {
    
    {
        std::map<std::string, std::string>::iterator i = _functokenmap.begin();
        for (; i != _functokenmap.end(); i++) {
            if (i->second == name) {
                _functokenmap.erase(i);
                break;
            }
        }
    }
    {
        map<string, shared_ptr<Func> >::iterator i = _funcs.find(name);
        if (i != _funcs.end())
            _funcs.erase(i);
    }
    
}

void Verbs::removeFunctions() {
    
    _funcs.clear();
    _functokenmap.clear();

}
    
pThing Verbs::getThing(TokenStream *ts) {
    pThing thing;
        _itp->getNextThing(_world, ts, &thing);
    return thing;
}
    
void Verbs::setBooleanResult(bool flag) {
    pThing t(new Thing(flag ? "TRUE" : "FALSE"));
    _world->setResult(t);
}
    
void Verbs::setLongResult(long n) {
    pThing t(new Thing());
    t->set(n);
    _world->setResult(t);
}
 
void Verbs::setDoubleResult(double n) {
    pThing t(new Thing());
    t->set(n);
    _world->setResult(t);
}

void Verbs::setStringResult(const std::string &s) {
    
    pThing t(new Thing(s));
    _world->setResult(t);

}

bool Verbs::equal(pThing thing1, pThing thing2) {
    
    if (thing1->isWord() && thing2->isWord())
        return thing1->getWord() == thing2->getWord();
    else if (thing1->isLong() && thing2->isLong())
        return thing1->getLong() == thing2->getLong();
    else if (thing1->isDouble() && thing2->isDouble())
        return thing1->getDouble() == thing2->getDouble();
    else if (thing1->isList() && thing2->isList())
        return thing1->getList().str() == thing2->getList().str();
    else if (thing1->isArray() && thing2->isArray())
        return thing1->getArray().getVector() == thing2->getArray().getVector();
    else
        return false;
}

}