import std.stdio;
import std.string;
import std.conv;

enum TokenType : string {EOF = "EOF", PLUS = "PLUS", INTEGER = "INTEGER"}

class Token(T) {
    T value;
    string type;

    this(T _value, string _type) {
        value = _value;
        type = _type;
    }

    override string toString() const{
        return "Token value: " ~ to!string(value) ~ "  type: " ~ type;
    }

}

class Interpreter {
    string expression;
    char currentChar;
    int position;

    this(string _exp) {
        expression = _exp;
        currentChar = '-';
        position = 0;
    }

    int express() {
        int result;

        return result;
    }

    Token getNextToken() {
        Token token;
        if(currentChar == ' ') {
            skipWhitespace();
        }
        if(position >= expression.length) {
            token = new Token!string("EOF", TokenType.EOF);
            return token;
        }
        if(currentChar == '+') {
            token = new Token!char('+', TokenType.PLUS);
            return token;
        }
        if(currentChar >= '0' && currentChar <= '9') {
            token = new Token!int(to!int(currentChar), TokenType.INTEGER);
            return token;
        }

        return token;
    }

    Token eat(string t) {
        Token token = getNextToken();
        assert(token.type == t);
        ++position;
        return token;
    }

    void skipWhitespace() {
        while(currentChar == ' ') {
            ++position;
            if(position >= expression.length) break;
            currentChar = expression[position];
        }
    }
}

void main() {
    while (true) {
        writeln("Enter expression : ");
        string input = readln();

        auto interpreter = new Interpreter(input);
        auto result = interpreter.express();
        writeln(result);
    }
}