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

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

#include "Interpreter.h"

#include "World.h"
#include "Verbs.h"
#include "Func.h"
#include "Console.h"
#include "Exceptions.h"
#include "Thing.h"
#include "List.h"
#include "Array.h"
#include "Tokenizer.h"
#include "StringTokenStream.h"

#include <iostream>
#include <sstream>
#include <algorithm>
#include <boost/lexical_cast.hpp>

using namespace std;
using namespace boost;

namespace phlogo {

Interpreter::Interpreter(World *world) {
        _verbs.reset(new Verbs(this, world));
        _tk.reset(new Tokenizer(_verbs.get()));
        _openfunc = 0;
        _debug = false;
}

wList Interpreter::sentence2words(const string &sentence) {
        vector<string> words;
        istringstream iss(sentence);
        copy(istream_iterator<string>(iss),
                 istream_iterator<string>(),
                 back_inserter<vector<string> >(words));
        return words;
}

void Interpreter::run(World *world, const string &sentence) {
        
    if (_debug) {
        cout << "i: " << sentence << std::endl;
    }
    try {
        string tokenized = _tk->tokenizeToString(sentence);
        runTokenized(world, tokenized);
    }
    catch( dont_know_how_exception & x ) {
        string *tokens=boost::get_error_info<errinfo_bad_tokens>(x);
        string *verb=boost::get_error_info<errinfo_curr_verb>(x);
        string *tag=boost::get_error_info<errinfo_tag>(x);
        string *value=boost::get_error_info<errinfo_value>(x);
        
        string err = "dont know how to";
        if (verb && *verb != "")
            err += " " + *verb;
        if (tokens && *tokens != "")
            err += " " + *tokens;
        if (tag && *tag != "") {
            if (*tag == "expr" && value && *value != "")
                err += " " + *value;
            else
                err += " " + *tag;
        }
        world->getConsole()->outputError(err);
    }
}

void Interpreter::runTokenized(World *world, const string &tokenized) {
    
    try {
        if (_debug) {
            cout << "t: " << tokenized << std::endl;
        }
        
        if (_openfunc) {
            _openfunc->addWords(tokenized);
        }
        else {
            // execute the words.
            StringTokenStream ts(tokenized);
            while (ts.hasMore())
                _verbs->run(&ts);
        }
    }
    catch( no_thing_exception & x ) {
        string *name=boost::get_error_info<errinfo_name>(x);
        world->getConsole()->outputError(*name + " has no value");
    }
    catch( bad_index_exception & x ) {
        world->getConsole()->outputError("bad index to array or list");
    }
    catch( interpreter_exception & x ) {
        world->getConsole()->outputError("unknown exception: " + current_exception_diagnostic_information());
    }
}

void Interpreter::defun(const string &name, const string &args) {
        _openfunc = _verbs->createFunction(name, args);
}

void Interpreter::end() {
        if (_openfunc == 0) {
                BOOST_THROW_EXCEPTION(
                        no_open_function_exception() );
        }
        else {
                _openfunc = 0;
        }
}

boost::shared_ptr<Thing> Interpreter::varOrLiteral(World *world, const string &s) {

        if (Verbs::isVariable(s))
                return world->getThing(Verbs::getVariable(s));
        else {
                boost::shared_ptr<Thing> thing(new Thing());
                thing->set(s);
                return thing;
        }
        
}

void Interpreter::getNextThing(World *world, TokenStream *ts, pThing *thing) {
        
        StringTokenStream *sts = static_cast<StringTokenStream *>(ts);
        
        // skip over leading space.
        sts->skipWs();
        
        switch (sts->nextChar()) {
        
        case '[':
                {
                        thing->reset(new Thing());
                        List list = (*thing)->allocList();
                        list.fromWord(sts);
                }
                break;
                
        case '{':
                {
                        thing->reset(new Thing());
                        Array array = (*thing)->allocArray(0);
                        array.fromWord(sts);
                }
                break;
                
        case '(':
                {
                        // find the last paren.
                        size_t i = sts->findEndSubExpression();

                        // run from here.
                        _verbs->run(sts);
                        *thing = world->getResult();
                        
                        // skip over closing paren, and then 
                        sts->finishSubExpression(i);
                }
                break;
                
        case '$':
        case '#':
                {
                        // run the verb, and get the resulting thing.
                        _verbs->run(sts);
                        *thing = world->getResult();
                }
                break;
        
        default:
                {
                        string t = sts->nextWord();
                        if (Verbs::isVariable(t))
                                *thing = world->getThing(Verbs::getVariable(t));
                        else {
                                thing->reset(new Thing());
                                (*thing)->set(t);
                        }
                }
                break;
        }
    if (_debug) {
        cout << thing->get()->type() << ": " << thing->get()->str() << std::endl;
    }

}

}