#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <stdexcept>
#include <stack>
#include <ctime>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>

#define DIGIT  '0' : case '1' : case '2' : case '3' : case '4' \
        : case '5' : case '6' : case '7' : case '8' : case '9'

class Befunge
{
    std::vector < std::string > code;

    int i, j;
    bool ascii_mode;
    enum Dir { Up, Down, Left, Right } direction;
    std::stack < int > mem;

    boost::random::mt19937 gen;
    boost::random::uniform_int_distribution < int > dist;

    // la fonction suivante s'assure que le programme est bien un rectangle et l'ajuste sinon
    void to_rectangle()
    {
        std::size_t max_size = 0;
        for(std::size_t i = 0; i < code.size(); ++i)
            if(code[i].size() > max_size)
                max_size = code[i].size();

        for(std::size_t i = 0; i < code.size(); ++i)
            code[i] += std::string(max_size - code[i].size(), ' ');
    }

    // calcule l'emplacement de la prochaine instruction
    void next_instr()
    {
        switch(direction)
        {
            case Up :
                --i; break;
            case Down :
                ++i; break;
            case Left :
                --j; break;
            case Right :
                ++j; break;
        }
    }

    // Accès à une instruction (+ correction toroïdale si nécessaire)
    char& access_instr(int& i_, int& j_)
    {
        // la grille du programme est en réalité un tore :
        while(i_ < 0)
            i_ = code.size() + i_;
        while(i_ >= static_cast < int >(code.size()))
            i_ -= code.size();
        while(j_ < 0)
            j_ = code[i_].size() + j_;
        while(j_ >= static_cast < int >(code[i_].size()))
            j_ -= code[i_].size();

        return code[i_][j_];
    }

    // Les trois fonctions suivantes facilitent la récupération des valeurs en sommet de pile :
    void get_mem(int& a)
    {
        a = mem.top(); mem.pop();
    }

    void get_mem(int& a, int& b)
    {
        get_mem(a);
        get_mem(b);
    }

    void get_mem(int& a, int& b, int& c)
    {
        get_mem(a, b);
        get_mem(c);
    }

  public :

    Befunge(const std::vector < std::string >& code_)
      : code(code_), dist(0, 3)
    {
        gen.seed(std::time(NULL));
        to_rectangle();
        init();
    }

    // On peut réinitialiser l'interpréteur, d'où une default-init en fonction distincte du constructeur
    void init()
    {
        i = j = 0;
        ascii_mode = false;
        direction = Right;
    }

    void start() // À appeler pour lancer l'interprétation
    {
        char instr;
        int a, b, c;

        while(true) // boucle principale de l'interpréteur
        {
            instr = access_instr(i, j);

            if(ascii_mode)
            { // si mode ascii, empiler la valeur ASCII de n'importe quel caractère
                if(instr == '"') // sauf '"' qui termine ce mode
                    ascii_mode = false;
                else mem.push(static_cast < int >(instr));
            }

            else switch(instr) // sinon, analyser et exécuter l'instruction
            {
                case ' ' : // continuer dans la même direction
                    break;

                case '@' : // fin du programme
                    goto end; // Si vous vous apprêtez à critiquer cette ligne, lire http://blog.huoc.org/goto.html puis s'abstenir

                case DIGIT :
                    mem.push(instr - '0');
                    break;

                // Opérations élémentaires :
                case '+' :
                    get_mem(a, b);
                    mem.push(a + b);
                    break;

                case '-' :
                    get_mem(a, b);
                    mem.push(b - a);
                    break;

                case '*' :
                    get_mem(a, b);
                    mem.push(a * b);
                    break;

                case '/' :
                    get_mem(a, b);
                    if(a == 0)
                        std::cin >> c;
                    else c = b / a;
                    mem.push(c);
                    break;

                case '%' :
                    get_mem(a, b);
                    if(a == 0)
                        std::cin >> c;
                    else c = b % a;
                    mem.push(c);
                    break;

                case '!' :
                    get_mem(a);
                    mem.push(!a);
                    break;

                case '`' :
                    get_mem(a, b);
                    mem.push(b > a);
                    break;

                // Changements de direction :
                case '>' :
                    direction = Right;
                    break;

                case '<' :
                    direction = Left;
                    break;

                case '^' :
                    direction = Up;
                    break;

                case 'v' :
                    direction = Down;
                    break;

                case '?' :
                    direction = static_cast < Dir >(dist(gen));
                    break;

                case '_' :
                    get_mem(a);
                    direction = (a == 0) ? Right : Left;
                    break;

                case '|' :
                    get_mem(a);
                    direction = (a == 0) ? Down : Up;
                    break;

                // Divers :
                case '"' : // Démarre le mode ASCII (si on se trouve là, c'est qu'il est préalablement désactivé)
                    ascii_mode = true;
                    break;

                case ':' : // duplique la valeur en sommet de pile
                    get_mem(a);
                    mem.push(a);
                    mem.push(a);
                    break;

                case '\\' : // inverse les deux valeurs en sommet de pile
                    get_mem(a, b);
                    mem.push(a);
                    mem.push(b);
                    break;

                case '$' : // supprime le sommet de pile
                    mem.pop();
                    break;

                case '.' :
                    get_mem(a);
                    std::cout << a; // affichage en tant qu'entier ...
                    break;

                case ',' :
                    get_mem(a);
                    std::cout << static_cast < char >(a); // ... ou en tant que caractère ASCII
                    break;

                case '#' : // saute l'instruction suivante
                    next_instr();
                    break;

                case 'p' : // modifier l'instruction à (a, b) en ASCII(c)
                    get_mem(a, b, c);
                    access_instr(a, b) = static_cast < char >(c);
                    break;

                case 'g' : // empile le code ASCII de l'instruction à (a, b)
                    get_mem(a, b);
                    mem.push(static_cast < int >(access_instr(a, b)));
                    break;

                case '&' : // demande un nombre et l'empile
                    std::cin >> a;
                    mem.push(a);
                    break;

                case '~' : // demande un caractère c et empile ASCII(c)
                    mem.push(static_cast < int >(std::getchar()));
                    break;

                default :
                    throw std::logic_error(std::string("Unexpected instruction : ") + instr);
            }

            next_instr(); // charge la prochaine instruction
        }

     end:
        return;
    }
};

int main(int argc, char* argv[])
{
    if(argc < 2)
    {
        std::cerr << "[Befunge] Merci d'indiquer un fichier source\n";
        return 1;
    }

    std::fstream file(argv[1], std::fstream::in);
    std::vector < std::string > code;

    // on récupère le code :
    while(file.good())
    {
        std::string line;
        std::getline(file, line);
        code.push_back(line);
    }

    Befunge interpreter(code);

    try {
        interpreter.start(); // on lance l'interprétation
    }
    catch(const std::exception& e)
    {
        std::cerr << "[Befunge] Error : " << e.what();
    }

    return 0;
}

int main(int argc, char* argv[])
{
    if(argc < 2)
    {
        std::cerr << "[Befunge] Merci d'indiquer un fichier source\n";
        return 1;
    }

    try {
        BefungeFile code(argv[1]); //je suis parti du principe qu'on pouvais lancer une exception s'il y avait une erreur lors de l'ouverture/de la lecture du fichier source
        Befunge interpreter(code);
        interpreter.start(); // on lance l'interprétation
    }
    catch(const std::exception& e)
    {
        std::cerr << "[Befunge] Error : " << e.what();
    }

    return 0;
}

#include <iostream>
#include <string>
#include <cctype>
#include <cmath>
#include <stdexcept>
#include <type_traits> // std::is_same
#include <algorithm> // std::remove_if
#include <functional> // std::equal_to

#include <boost/mpl/assert.hpp>
#include <boost/unordered_map.hpp>
#include <boost/function.hpp>

namespace calculator
{
    template < typename Iterator >
    class Parser
    {
      public : // typedef publics...

        typedef Iterator iterator;
        typedef typename Iterator::value_type value_type;

      private :

        double last; // conserve le dernier résultat
        iterator begin, end; // le "range" à parser
        std::size_t pos;

        boost::unordered_map < std::string, double > const_; // les constantes
        boost::unordered_map < std::string, boost::function < double(double) > > funs; // les fonctions

        // quelques méthodes bien pratiques :

        value_type forward()
        {
            value_type ret = *begin++;
            ++pos;
            return ret;
        }

        bool match(const value_type& c)
        {
            if(begin == end || *begin != c)
                return false;
            forward();
            return true;
        }

        void eat(const value_type& c)
        {
            if(!match(c))
                throw std::logic_error(std::string("'") + c + "' is expected");
        }

        int match_digit()
        {
            int n = -1;
            if(begin != end && std::isdigit(*begin))
                n = forward() - '0';
            return n;
        }

      public : // Constructeur et parsing :

        Parser()
          : last(0.)
        {
            BOOST_MPL_ASSERT((std::is_same < value_type, char >));

            const_["pi"] = 3.1415926535;
            const_["e"]  = 2.7182818284;
            const_["or"] = 1.6180339887;

            typedef double(*fun)(double);

#define MAP(name, stdfun) funs[#name] = static_cast < fun >(std::stdfun);
            MAP(cos, cos)
            MAP(sin, sin)
            MAP(tan, tan)
            MAP(acos, acos)
            MAP(asin, asin)
            MAP(atan, atan)
            MAP(cosh, cosh)
            MAP(sinh, sinh)
            MAP(tanh, tanh)
            MAP(exp, exp)
            MAP(ln, log)
            MAP(log, log10)
            MAP(sqrt, sqrt)
            MAP(abs, fabs)
            MAP(ceil, ceil)
            MAP(floor, floor)
#undef MAP
        }

        std::size_t position()
        {
            return pos;
        }

        double start(iterator begin_, iterator end_)
        {
            begin = begin_, end = end_;
            pos = 0;

            double n = expr();
            if(begin != end)
                throw std::logic_error("Incomplete parsing");
            return (last = n);
        }

        // the parse members :

        double expr() // + et -
        {
            double n = term();

            while(begin != end)
                  if(match('+')) n += term();
             else if(match('-')) n -= term();
             else break;

            return n;
        }

        double term() // * et /
        {
            double n = pow_();

            while(begin != end)
                  if(match('*')) n *= pow_();
             else if(match('/')) n /= pow_();
             else break;

            return n;
        }

        double pow_() // uniquement ^
        {
            double n = fact();
            if(match('^'))
                n = std::pow(n, pow_());
            return n;
        }

        double fact() // opérandes les plus prioritaires :
        {
            double n = 0.;

            if(begin == end)
                throw std::logic_error("Missing factor");

            // plusieurs styles de parenthèses :
            if(match('('))
                n = expr(), eat(')');
            else if(match('['))
                n = expr(), eat(']');

            // signe d'une expression :
            else if(match('-'))
                n = -fact();
            else if(match('+'))
                n = fact();

            // constantes numériques, mathématiques ou appels de fonction :
            else if(std::isdigit(*begin))
                n = number();

            else if(std::isalpha(*begin))
            {
                std::string id = ident();

                if(id == "last") // demande le dernier résultat calculé
                    n = last;

                else if(match('(')) // c'est un appel de fonction
                {
                    if(funs.find(id) == funs.end())
                        pos -= 2, // on ne tient plus compte de '('
                        throw std::logic_error(id + " is not a function");

                    n = funs[id](expr()), eat(')');
                }
                else // c'est une constante
                {
                    if(const_.find(id) == const_.end())
                        --pos,
                        throw std::logic_error(id + " is not a constant");
                    n = const_[id];
                }
            }

            else throw std::logic_error("Unexpected input");

            return n;
        }

        double number() // le role de cette méthode est de parser un nombre entier ou à virgule flottante
        {
            int t;
            double n = 0., d = 10.;

            while((t = match_digit()) != -1)
                n = 10. * n + static_cast < double >(t);

            if(match('.'))
                while((t = match_digit()) != -1)
                    n += static_cast < double >(t) / d, d *= 10.;
            return n;
        }

        std::string ident() // récupère un identifiant
        {
            iterator it = begin;
            while(begin != end && std::isalnum(*begin))
                forward();

            return std::string(it, begin);
        }
    };
}

int main()
{
    std::string expr;
    calculator::Parser < std::string::const_iterator > parser;

    while(true)
    {
        std::cout << "# ";
        std::getline(std::cin, expr);

        if(expr == "exit")
            break;

        expr.erase(std::remove_if(expr.begin(), expr.end(), std::bind1st(std::equal_to < char >(), ' ')), expr.end());
        try
        {
            std::cout << "> ";
            std::cout << parser.start(expr.begin(), expr.end()) << std::endl;
        }
        catch(const std::exception& err)
        {
            std::cout << "Error : " << err.what() << std::endl;
            std::cout << "> " << expr << std::endl;
            std::cout << std::string(parser.position() + 2, ' ') << '^' << std::endl;
        }
    }

    return 0;
}