/*
 * primitive.h
 *
 *  Created on: Feb 11, 2010
 *      Author: petergoodman
 *     Version: $Id$
 */

#ifndef PRIMITIVE_H_
#define PRIMITIVE_H_

#include <string>
#include <iostream>
#include <deque>
#include <map>
#include <stdexcept>
#include <utility>

#include "Token.h"
#include "DerivedFunction.h"
#include "TokenStackConstraint.h"

namespace primitive {

    using namespace std;
    using namespace TS;

    void exit(deque<Token *> &stack,
              deque<Token *> &tokens,
              map<string, Token *> &symbols);

    void clear(deque<Token *> &stack,
               deque<Token *> &tokens,
               map<string, Token *> &symbols);

    void print(deque<Token *> &stack,
               deque<Token *> &tokens,
               map<string, Token *> &symbols);

    void exec(deque<Token *> &stack,
              deque<Token *> &tokens,
              map<string, Token *> &symbols);

    void pop(deque<Token *> &stack,
             deque<Token *> &tokens,
             map<string, Token *> &symbols);

    void dump(deque<Token *> &stack,
              deque<Token *> &tokens,
              map<string, Token *> &symbols);

    void load(deque<Token *> &stack,
              deque<Token *> &tokens,
              map<string, Token *> &symbols);

    void store(deque<Token *> &stack,
               deque<Token *> &tokens,
               map<string, Token *> &symbols);

    void cond(deque<Token *> &stack,
              deque<Token *> &tokens,
              map<string, Token *> &symbols);

    typedef Token *(op2_func_t)(Token *, Token *);

    pair<Token *, Token *> take2(deque<Token *> &stack);

    Token *op_add(Token *a, Token *b);
    Token *op_sub(Token *a, Token *b);
    Token *op_mul(Token *a, Token *b);
    Token *op_div(Token *a, Token *b);
    Token *op_eq(Token *a, Token *b);
    Token *op_gt(Token *a, Token *b);
    Token *op_lt(Token *a, Token *b);

    /* fix template linkage problems; a bit of bloat here means a bit less 
     * elsewhere :D */

    /**
     * Create an operator on two integers from a simple function that 
     * performs the operation.
     */
    template<op2_func_t *op>
    void op2(deque<Token *> &stack,
             deque<Token *> &tokens,
             map<string, Token *> &symbols) {
        (void) tokens;
        (void) symbols;
    
        And<MinSize<2>,  // type check
            And<Type<Token::INT>, Type<Token::INT> > > constraint(stack);
        (void) constraint;
    
        pair<Token *, Token *> both = take2(stack);
        stack.push_back(op(both.first, both.second));
        delete both.first;
        delete both.second;
    }
}

#endif /* PRIMITIVE_H_ */