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

/*
 *  Verbs.h
 *
 *  Author: Paul Hamilton
 *      Date: 6 Jun 2011
 *
 */
#ifndef _VERBS_H
#define _VERBS_H

#include "Types.h"

#include <string>
#include <iterator>
#include <vector>
#include <map>
#include <boost/function.hpp>

namespace phlogo {
        
class Interpreter;
class World;
class Func;
class Iterators;

class Verbs {

private:
        Interpreter *_itp;
        World *_world;
        
public:
        Verbs(Interpreter *itp, World *world);
        
        void run(TokenStream *ts);

        Func *createFunction(const std::string &name, const std::string &args);
        
        static bool isVariable(const std::string &s) {
                return s[0] == ':';
        }
        
        static std::string getVariable(const std::string &s) {
                return s.substr(1, s.length()-1);
        }
        
        const std::map<std::string, std::string> &getVerbTokenMap() { return _verbtokenmap; }
        const std::map<std::string, std::string> &getFuncTokenMap() { return _functokenmap; }
        
        static size_t safeNext(size_t i, size_t end) {
                return i == end || i == std::string::npos ? end : i+1;
        }
        
    void removeFunction(const std::string &name);
    void removeFunctions();
    
private:

        std::map<std::string, std::string> _verbtokenmap;
        std::map<std::string, pVerb> _map;
        std::map<std::string, std::string> _functokenmap;
        std::map<std::string, boost::shared_ptr<Func> > _funcs;
        
        Func *getFunction(const std::string &name);
        void addMap(const std::string &verb, const std::string &token, pVerb func);
    long getLong(TokenStream *ts);
    double getDouble(TokenStream *ts);
    double getNum(TokenStream *ts, bool *isdouble);
    std::string getWord(TokenStream *ts);
    pThing getThing(TokenStream *ts);
    void setBooleanResult(bool flag);
    void setLongResult(long n);
    void setDoubleResult(double n);
    void setStringResult(const std::string &s);
    bool equal(pThing thing1, pThing thing2);
        
        // Basic Verbs
        void print(TokenStream *ts);

        void clearscreen(TokenStream *ts);

        void add(TokenStream *ts);
        void mul(TokenStream *ts);
        void div(TokenStream *ts);
        void sub(TokenStream *ts);

        void make(TokenStream *ts);

        void thing(TokenStream *ts);

        void output(TokenStream *ts);

    // File verbs
        void load(TokenStream *ts);

    // Unit verbs
        void test(TokenStream *ts);
    
        void testsuite(TokenStream *ts);

        // Constructor verbs
        void catenateWords(TokenStream *ts, const char *sep);
                
        void word(TokenStream *ts);

        void sentence(TokenStream *ts);

        void list(TokenStream *ts);

        // used by lput and fput
        void listput(TokenStream *ts, bool front);
                
        void fput(TokenStream *ts);
        
        void lput(TokenStream *ts);

        void array(TokenStream *ts);

        void mdarray(TokenStream *ts);

        void listtoarray(TokenStream *ts);

        void arraytolist(TokenStream *ts);

        void combine(TokenStream *ts);

        void reverse(TokenStream *ts);

        // the next symbol.
        static int gSymbol;

        void gensym(TokenStream *ts);

        // Data Selector Verbs
        void first(TokenStream *ts);

        void firsts(TokenStream *ts);

        void last(TokenStream *ts);

        void butfirst(TokenStream *ts);

        void butfirsts(TokenStream *ts);

        void butlast(TokenStream *ts);

        void item(TokenStream *ts);

        void mditem(TokenStream *ts);

        void pick(TokenStream *ts);

        void remove(TokenStream *ts);

        void remdup(TokenStream *ts);

        void quoted(TokenStream *ts);

        // data mutator verbs
        void setitem(TokenStream *ts);

        void mdsetitem(TokenStream *ts);

        void setfirst(TokenStream *ts);

        void setbf(TokenStream *ts);

        void push(TokenStream *ts);

        void pop(TokenStream *ts);

        void queue(TokenStream *ts);

        void dequeue(TokenStream *ts);

        // predicate verbs
        void wordp(TokenStream *ts);
        void listp(TokenStream *ts);
        void arrayp(TokenStream *ts);
        void emptyp(TokenStream *ts);
        void equalp(TokenStream *ts);
        void notequalp(TokenStream *ts);
        void beforep(TokenStream *ts);
        void eq(TokenStream *ts);
        void memberp(TokenStream *ts);
        void substringp(TokenStream *ts);
        void numberp(TokenStream *ts);
    
        // query verbs
        void count(TokenStream *ts);
        void ascii(TokenStream *ts);
        void ch(TokenStream *ts);
        void member(TokenStream *ts);
        void lowercase(TokenStream *ts);
        void uppercase(TokenStream *ts);
    
        // arithmetic verbs
        void sum(TokenStream *ts);
        void difference(TokenStream *ts);
        void minus(TokenStream *ts);
        void product(TokenStream *ts);
        void quotient(TokenStream *ts);
        void remainder(TokenStream *ts);
        void integer(TokenStream *ts);
        void round(TokenStream *ts);
        void sqrt(TokenStream *ts);
        void power(TokenStream *ts);
        void exp(TokenStream *ts);
        void log10(TokenStream *ts);
        void ln(TokenStream *ts);
        void sin(TokenStream *ts);
        void radsin(TokenStream *ts);
        void cos(TokenStream *ts);
        void radcos(TokenStream *ts);
        void arctan(TokenStream *ts);
        void radarctan(TokenStream *ts);
        void iseq(TokenStream *ts);
        void rseq(TokenStream *ts);
    
    void lessp(TokenStream *ts);
    void greaterp(TokenStream *ts);
    void lessequalp(TokenStream *ts);
    void greaterequalp(TokenStream *ts);

    // random verbs
    void random(TokenStream *ts);
    void rerandom(TokenStream *ts);

    // format verbs
    void form(TokenStream *ts);
    
    // bit verbs
    void bitAnd(TokenStream *ts);
    void bitOr(TokenStream *ts);
    void bitxor(TokenStream *ts);
    void bitnot(TokenStream *ts);
    void lshift(TokenStream *ts);
    
    // logical verbs
    void And(TokenStream *ts);
    void Or(TokenStream *ts);
    void Not(TokenStream *ts);
    
    // turtle graphics
        void fd(TokenStream *ts);
        void bk(TokenStream *ts);
    
        void lt(TokenStream *ts);
        void rt(TokenStream *ts);
    
        void setpos(TokenStream *ts);
        void setxy(TokenStream *ts);
        void setx(TokenStream *ts);
        void sety(TokenStream *ts);
        void setheading(TokenStream *ts);
        void home(TokenStream *ts);

        void pos(TokenStream *ts);
        void xcor(TokenStream *ts);
        void ycor(TokenStream *ts);
        void heading(TokenStream *ts);
        void towards(TokenStream *ts);

    // workspace
        void contents(TokenStream *ts);
        void procedures(TokenStream *ts);
        void primitives(TokenStream *ts);
        void names(TokenStream *ts);
    
        void erase(TokenStream *ts);
        void erall(TokenStream *ts);
        void erps(TokenStream *ts);
        void erns(TokenStream *ts);
        void ern(TokenStream *ts);
    
        void procedurep(TokenStream *ts);
        void primitivep(TokenStream *ts);
        void namep(TokenStream *ts);

    void repeat(TokenStream *ts);

    void penup(TokenStream *ts);

    void pendown(TokenStream *ts);
};

}

#endif // _VERBS_H