#include <iostream>

#include "interpret"

using namespace std;

int main(){

    translator N("ReadFile");

    N.interpret();

    return 0;

}

#ifndef __CLASS_INTERPRET__

#define __CLASS_INTERPRET__

#include <fstream>

#include <sstream>

#include <string>

#include <stack>

#include <queue>

#include <new>

#include <cstdlib>

// This is My classes..

#include "vector_/vector.hpp"

#include "Calc/calc.h"

// Function IDX AREA

#define PRINT 0

#define INPUT 1

// Function IDX END AREA

typedef unsigned long long DWORD;

// Interpreter Pattern?

// N_interpert - Function::print, input

class N_interpret{

    public:

        bool is_command(std::string ic, unsigned int &c_NUM);

        bool shell(std::string command);

        virtual bool interpret() = 0;

};

class translator : public N_interpret{

    private:

        std::ifstream FS;

    protected:

        vector<std::string> buf;

    public:

        translator() { }

        translator(std::string path) {

            FS.open(path);

            std::string _b;

            while(!FS.eof()){

                getline(FS, _b);

                if(_b.length() != 0)

                    buf.push_back(_b);  // File Getline and Save Vector<string>

            }

            FS.close();

        }

        virtual bool interpret();

};

class com_print{

    public:

        std::string trim(std::string &str);

        virtual std::string interpret(std::string str){

            if(str[1] == '\"')

                return "STRING";

            else if(str[1] >= '0' && str[1] <= '9')

                return "CALC";

            else

                return "";

        }

};

class print_str : public com_print{

    public:

        virtual std::string interpret(std::string str){

            std::string arg;

            Calculator<std::string> *calc = new Calculator<std::string>(str, STRING);

            arg = calc->in2post();

            arg = calc->calc(arg);

            std::cout << arg << std::endl;

            return arg;

        }

};

// Perpect Calculator! XD But.. type_string is not working this situation..

class print_calc : public com_print{

    public:

        std::string interpret(std::string str){

            std::string post;

            std::stringstream ss;

            DWORD ret;

            Calculator<long long> *calc = new Calculator<long long>(trim(str));

            post = calc->in2post();

            ret = calc->calc(post);

            ss << ret;

            std::cout << ret << std::endl;

            return ss.str();

        }

};

class print_func : public com_print{

    public:

        std::string interpret(std::string str){

            return str;

        }

};

class print_ptr : public com_print{

    public:

        std::string interpret(std::string str){

            return str;

        }

};

bool N_interpret::is_command(std::string ic, unsigned int &c_NUM){

    if(ic == "print"){

        c_NUM = PRINT;

        return true;

    }

    else

        c_NUM = 9505;

    return false;

}

bool N_interpret::shell(std::string command){

    std::string arg, com;

    char *_command = (char *)(command.c_str());

    unsigned int NUM, i;

    while(*_command){

        if(*_command != ' '){

            com += *_command;

            _command++;

        }

        else

            break;

    }

    // Check command list.. (#define)

    // PRINT : 0

    // INPUT : 1

    if(is_command(com, NUM)){

        switch(NUM){

            case PRINT:

                com_print *cPrint = new com_print;

                std::string option = cPrint->interpret(_command);

                if(option == "STRING"){

                    print_str *strPrint = new print_str;

                    if(*_command == ' ')

                        _command++;

                    strPrint->interpret(_command);

                    delete strPrint;

                }

                else if(option == "CALC"){

                    print_calc *calcPrint = new print_calc;

                    if(*_command == ' ')

                        _command++;

                    calcPrint->interpret(_command);

                    delete calcPrint;

                }

                else if(option == "FUNC"){

                }

                else if(option == "PTR"){

                }

                delete cPrint;

                return true;

        }

    }

    else

        std::cout << "UnKnown command... ;(" << std::endl;

    return false;

}

bool translator::interpret(){

    std::string _b;

    vector<std::string>::iterator iter;

    for(iter = buf.begin(); iter != buf.end(); iter++){

        if(shell(*iter)){

        }else break;

    }

}

std::string com_print::trim(std::string &str){

    std::string ret = "";

    int i;

    for(i = 0; i < str.length(); i++){

        if(str[i] != ' ')

            ret += str[i];

    }

    return ret;

}

#endif

/*

    Calculator!!

                - KuroNeko

    :: Expression ::

    Nope..

*/

#include <iostream>

#include <stack>

#include <string>

#include <cstring>

#include "../vector_/vector.hpp"

typedef unsigned long long DWORD;

#define DEFAULT 0

#define STRING 1

template<typename T>

class Calculator{

    private:

        std::string buf;

    public:

        Calculator(std::string expr){

            if(expr.length() > 0)

                buf = trim(expr);

            else

                buf = "Unknown";

        }

        Calculator(std::string expr, int type){

            if(expr.length() > 0){

                if(type == DEFAULT)

                    buf = trim(expr);

                else

                    buf = expr;

            }

            else

                buf = "Unknown";

        }

        std::string in2post();

        int op_pri(char a){

            if(a == '+' || a == '-' || a == ' ')

                return 1;

            else if(a == '*' || a == '/')

                return 2;

            else if(a == '(' || a == ')' || a == '\"' || a == '\'')

                return 0;

            else return -1;

        }

        T calc(std::string post_expr);

        DWORD pow(int a, int b){

            DWORD ret = 1, i;

            for(i = 0; i < b; i++)

                ret *= a;

            return ret;

        }

        std::string trim(std::string &str){

            std::string ret = "";

            int i;

            for(i = 0; i < str.length(); i++){

                if(str[i] != ' ')

                    ret += str[i];

            }

            return ret;

        }

};

template<typename T>

std::string Calculator<T>::in2post(){

    if(buf == "Unknown"){

        std::cout << "syntax error.." << std::endl;

        return "Unknown";

    }

    int i, k, pri;

    char top_op;

    std::string ret = "";

    std::stack<char> st;

    for(i = 0; i < buf.length(); i++){

        switch(buf[i]){

            case '(': st.push(buf[i]); break;

            case ')': 

                while(st.top() != '('){

                    ret += st.top();

                    st.pop();

                }

                st.pop();

                break;

            case '+': case '-': case '*': case '/':

                while(!st.empty() && op_pri(st.top()) >= op_pri(buf[i])){

                    ret += st.top();

                    st.pop();

                }

                st.push(buf[i]);

                st.push(' ');

                ret += ' ';

                break;

            default:

                ret += buf[i];

                break;

        }

    }

    while(!st.empty()){

        ret += st.top();

        st.pop();

    }

    return ret;

}

template<>

std::string Calculator<std::string>::in2post(){

    if(buf == "Unknown"){

        std::cout << "syntax error.." << std::endl;

        return "Unknown";

    }

    int i, q, cnt = 1;

    char top_op;

    std::string str, ret = "";

    std::stack<char> st;

    long long quote = 0;

    for(i = 0; i < buf.length(); i++){

        switch(buf[i]){

            case '\"':

                if(buf[i] == '\"'){

                    ret += '\"';

                    i++;

                    while(buf[i] != '\"')

                        ret += buf[i++];

                    ret += buf[i];

                    quote++;

                }

                else if(quote % 2 + 1 == 2) ret += buf[i];

                break;

            case '+':

                while(!st.empty() && op_pri(st.top()) >= op_pri(buf[i])){

                    ret += st.top();

                    st.pop();

                }

                st.push(buf[i]);

                break;

        }

    }

    while(!st.empty()){

        ret += st.top();

        st.pop();

    }

    return ret;

}

template<typename T>

T Calculator<T>::calc(std::string post_expr){

    if(post_expr != "Unknown" || buf != "Unknown"){

        std::stack<T> st;

        std::string str;

        DWORD i = 0, cnt = 0;

        T value, op1, op2;

        for(i = 0; i < post_expr.length(); i++){

            if(post_expr[i] >= '0' && post_expr[i] <= '9'){

                str = "";

                while(post_expr[i + cnt] != ' '){

                    cnt++, str+= post_expr[i + cnt - 1];

                }

                i += cnt;

                value = strtol(str.c_str(), NULL, 10);

                cnt = 0;

                st.push(value);

            }

            else{

                if(post_expr[i] != ' '){

                    op2 = st.top();

                    st.pop();

                    op1 = st.top();

                    st.pop();

                    switch(post_expr[i]){

                        case '+': value = op1 + op2; break;

                        case '-': value = op1 - op2; break;

                        case '*': value = op1 * op2; break;

                        case '/': value = op1 / op2; break;

                    }

                    st.push(value);

                }

            }

        }

        return st.top();

    }

    else

        std::cout << "syntax error.." << std::endl;

}

template<>

std::string Calculator<std::string>::calc(std::string post_expr){

    if(post_expr != "Unknown" || buf != "Unknown"){

        std::stack<std::string> st;

        std::string str;

        DWORD i = 0, cnt = 1;

        std::string value, op1, op2;

        char *p;

        for(i = 0; i < post_expr.length(); i++)

            if(post_expr[i] == '\"')

                cnt++;

        if(cnt % 2 == 2)

            return "Error..";

        value = std::string(strtok((char *)post_expr.c_str(), "\""));

        st.push(value);

        while(p = strtok(NULL, "\"")){

            if(strchr(p, '+') != NULL){

                op2 = st.top();

                st.pop();

                op1 = st.top();

                st.pop();

                st.push(op1 + op2);

            }

            else{

                st.push(std::string(p));

            }

        }

        return st.top();

    }

    else

        std::cout << "syntax error.." << std::endl;

}

#include "c_interpret.h"