using System;

using System.Collections.Generic; 

​

public enum TokenTypes { Symbol, Number }

​

public class Token

{

    public TokenTypes Type { get; set; }

    public object Value { get; set; }

    public Token(TokenTypes T, object v) { Value = v; Type = T; }

    public override string ToString() { return "<" + Type + ", " + Value.ToString() + ">"; }

}

​

public class Lexer 

{

    private IList<Token> Tokens;

    private int CurrentCharPos;

    private string Input;

    private char CurrentChar { get { return (CurrentCharPos >= Input.Length) ? '\0' : Input[CurrentCharPos]; } }

    private char NextChar { get { return (CurrentCharPos + 1 >= Input.Length) ? '\0' : Input[CurrentCharPos + 1]; } }

    private bool IsEOF { get { return CurrentCharPos >= Input.Length; } }

    private bool IsSymbol { 

        get { 

            return (CurrentChar == '+' || CurrentChar == '-' || CurrentChar == '*' || CurrentChar == '/') || (CurrentChar == '(' || CurrentChar == ')'); 

        } 

    }

    private bool IsDigit { get { return (CurrentChar >= '0' && CurrentChar <= '9'); } }

    private bool IsNegNumber { get { return (CurrentChar == '-' && (NextChar >= '0' && NextChar <= '9')); } }

    private void ScanNumber(bool neg = false)

    {

        if (neg) ++CurrentCharPos;

        string thestring = "";

        while (!IsEOF && IsDigit) {

            thestring += CurrentChar;

            ++CurrentCharPos; }

        int val = int.Parse(thestring);

        if (neg) val = val * -1; // Convert to negative c:

        Tokens.Add(new Token(TokenTypes.Number, val));

    }

    private void ScanSymbol() 

    {

        Tokens.Add(new Token(TokenTypes.Symbol, CurrentChar));

        ++CurrentCharPos;

    }

    public IList<Token> Scan(string inp) 

    {       

        CurrentCharPos = 0; Tokens.Clear(); Input = inp;

        while (!IsEOF)

        {

            if (CurrentChar == ' ' || CurrentChar == '\t' || CurrentChar == '\r' || CurrentChar == '\n')

                ++CurrentCharPos;

            else if (IsNegNumber)

                ScanNumber(true);

            else if (IsDigit)

                ScanNumber();

            else if (IsSymbol)

                ScanSymbol();

            else 

            {

                Console.WriteLine("Unexpected character: " + CurrentChar + "\n"); 

                break;

            }

        }

        return Tokens;

    }

    public Lexer()

    {

        Tokens = new List<Token>(); Input = "";

    }

}

​

public class Converter

{

    public static IDictionary<char, int> Precedence;

    public static void Configure() {

        Precedence = new Dictionary<char, int>();

        Precedence.Add('+', 1);

        Precedence.Add('-', 1);

        Precedence.Add('*', 2);

        Precedence.Add('/', 2);

        Precedence.Add('(', 3);

        Precedence.Add(')', 3);

    }

    public static void PrintInfix(IList<Token> toks) {

        foreach (Token t in toks) Console.Write(t.Value.ToString() + " ");

        Console.WriteLine("\n");

    }

    public static void PrintPostfix(IList<Token> toks) {

        List<Token> tmptoks = new List<Token>();

        Stack<Token> OpStack = new Stack<Token>();

        int i = 0;

        while (i < toks.Count)

        {

            if (toks[i].Type == TokenTypes.Number)

            {

                tmptoks.Add(toks[i]); ++i;

            }

            else if (toks[i].Type == TokenTypes.Symbol)

            {

                if (OpStack.Count > 0)

                    if (Precedence[(char)OpStack.Peek().Value] < Precedence[(char)toks[i].Value])

                    {

                        OpStack.Push(toks[i]); tmptoks.Add(toks[++i]);

                    }

            }

        }

    }

    public static void PrintPrefix(IList<Token> toks) {

    }

}

​

​

public class Program

{

    public static void Main()

    {

        Lexer L = new Lexer(); string s = "";

        Converter.Configure();

        while (true)

        {

            Console.Write(">>> ");

            s = Console.ReadLine();

            Converter.PrintInfix(L.Scan(s));

        }

    }

}