using System;

using System.Collections.Generic;

​

public enum TokenTypes

{

    String, // " <any other char than ' " '>+ "

    Number, // <digit>+

    Symbol, // Down.

    Ident,  // any char different from [ " " ] 

    Keyword, // if, else, void, sub, func, etc..

    Char // For C# script parsing...

}

​

// This enum contains the symbols information.

public enum Symbols

{

    //  +    -    *    /    %    =

    Add, Sub, Mul, Div, Mod, Equals,

    //  <=            <       ==         !=         >        >=             !    &&   ||  ^

    LesserEquals, Lesser, CompEquals, NotEquals, Greater, GreaterEquals, Not, And, Or, Xor,

    //  (            )             [            ]             {          }

    LeftParenth, RightParenth, LeftBracket, RightBracket, LeftBrace, RightBrace,

    //  :      ;          ,      .    $      @   #

    Colon, Semicolon, Comma, Dot, Money, At, Sharp, Question,

    //  &           |          <<         >>

    BitwiseAnd, BitwiseOr, LeftShift, RightShift,

    //  ++         --         +=    -=      *=     /=

    Increment, Decrement, AddTo, SubTo, MulBy, DivBy,

    //  \            ~

    InvertedBar, Destructor

}

​

public enum Keywords

{

    Null // TODO: Place your keywords here if you want to use them as an enum.

}

​

public static class Extensions

{

    // Chars:

    public static bool IsLetter(this char c)

    {

        return ((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z'));

    }

    public static bool IsDigit(this char c)

    {

        return (c >= '0') && (c <= '9');

    }

    // Checks whether the character is a supported symbol.

    public static bool IsSymbol(this char c)

    {           // Arith

        return (c == '+') || (c == '-') || (c == '*') || (c == '/') || (c == '%') || (c == '=')

            // Brackets

            || (c == '(') || (c == ')') || (c == '{') || (c == '}') || (c == '[') || (c == ']')

            // Other Symbols

            || (c == ':') || (c == ';') || (c == ',') || (c == '.') || (c == '#') || (c == '@') || (c == '$')

            // Logical and Bitwise

            || (c == '&') || (c == '|') || (c == '!') || (c == '^') || (c == '<') || (c == '>')

            // Some others

            || (c == '\\') || (c == '~') || (c == '?');

    }

    // Strings:

    public static bool IsDoubleOp(this string s)

    {       // Arithmethics

        return (s == "++") || (s == "--") 

            // Addition

            || (s == "+=") || (s == "-=") || (s == "*=") || (s == "/=") 

            // Logical

            || (s == "<=") || (s == "==") || (s == "!=") || (s == ">=")

            || (s == "&&") || (s == "||") 

            // Shifts

            || (s == "<<") || (s == ">>");

    }

    public static bool IsKeyword(this string s)

    {

        // TODO: Place your keywords here.

        return false; // otherwise, everything will be an ident.

    }

}

​

public class Token

{

    public TokenTypes Type { get; private set; }

    public object Value { get; private set; }

    public Token(TokenTypes _type, object _value)

    {

        Type = _type;

        Value = _value;

    }

    public override string ToString()

    {

        return "Type: " + Type.ToString() + "\t\t Value: " + Value.ToString();

    }

}

​

​

public class tLexer

{

    #region Fields

        private int _charpos;

    private char[] Input;

    public IList<Token> Tokens { get; private set; }

    #region Character Handling

        private int CharPosition

    {

        get { return _charpos; }

        set 

        {

            _charpos += value; // Be careful with this it's used to "increment" the var value.

        }

    }

    private char CurrentChar

    {

        get 

        {

            try { return Input[CharPosition]; }

            catch { return '\0'; }

        }

    }

    private char NextChar

    {

        get

        {

            try { return Input[CharPosition + 1]; }

            catch { return '\0'; }

        }

    }

    #endregion

        // Some other kind of handling

        private bool IsEOF { get { return (CharPosition + 1 == Input.Length); } }

    private bool IsLineFeed { get { return (CurrentChar == '\t') || (CurrentChar == '\r') || (CurrentChar == '\n'); } }

    private bool IsDoubleSymbol

    {

        get

        {

            string Op = CurrentChar.ToString() + NextChar.ToString();

            return (Op == "++") || (Op == "--")

                || (Op == ">=") || (Op == "==") || (Op == "!=") || (Op == "<=")

                || (Op == "&&") || (Op == "||")

                || (Op == "+=") || (Op == "-=") || (Op == "*=") || (Op == "/=");

        }

    }

    private bool IsComment { get { return (CurrentChar == '/' && NextChar == '/'); } }

    #endregion

        #region Private Scanning Methods

        private void ScanString()

    {

        CharPosition = 1; // Eats the '"'

        string theString = ""; 

        while (CurrentChar != '"' && !IsEOF)

        {

            if (CurrentChar == '\\')

            {

                switch (NextChar)

                {

                    case '\\': theString += "\\"; break;

                    case 'r': theString += "\r"; break;

                    case 'n': theString += "\n"; break;

                    case 't': theString += "\t"; break;

                    default: throw new Exception("Unsupported literal: '" + NextChar.ToString() + "', aborting.");

                }

                CharPosition = 2; // Eats the '\%'

                continue;

            }

            // Otherwise, continue.

            theString += CurrentChar; // break;

            CharPosition = 1;

        }

        if (IsEOF && CurrentChar != '"') throw new Exception("Unterminated string, aborting.");

        CharPosition = 1; // Eats the last '"'

        Tokens.Add(new Token(TokenTypes.String, theString));

    }

    private void ScanChar()

    {

        CharPosition = 1; // Eats the first '

        if (CurrentChar == '\'')

            throw new Exception("Empty char literal.");

        char c = CurrentChar; CharPosition = 1; // Eats the char value.

        if (CurrentChar != '\'')

            throw new Exception("Expected ending char literal.");

        CharPosition = 1; // Eats the last '

        Tokens.Add(new Token(TokenTypes.Char, c));

    }

    private void ScanIdentOrKeyword()

    {

        string theString = "";

        while (!IsEOF && (CurrentChar != ' ' && (CurrentChar.IsLetter() || CurrentChar.IsDigit() || CurrentChar == '_')))

        {

            theString += CurrentChar;

            CharPosition = 1;

        }

        // TODO: Check method whether is a keyword or not.

        Tokens.Add(new Token(TokenTypes.Ident, theString));

    }

    private void ScanNumber()

    {

        string theString = ""; // Main decimal input.

        while (CurrentChar.IsDigit())

        {

            theString += CurrentChar;

            CharPosition = 1;

        }

        if (CurrentChar == '.') 

        {

            theString += ".";

            CharPosition = 1; // Adds the decimal dot and skips it.

            while (CurrentChar.IsDigit())

            {

                theString += CurrentChar; 

                CharPosition = 1;

            }

        }

        Tokens.Add(new Token(TokenTypes.Number, double.Parse(theString))); // Ah, yeah, all numbers are 64-bit floating point.

    }

    private void ScanSymbol()

    {

        Symbols S;

        switch (CurrentChar)

        {

            // Arith:

            case '+': S = Symbols.Add; break;

            case '-': S = Symbols.Sub; break;

            case '*': S = Symbols.Mul; break;

            case '/': S = Symbols.Div; break;

            case '%': S = Symbols.Mod; break;

            case '=': S = Symbols.Equals; break;

            // Braces:

            case '(': S = Symbols.LeftParenth; break;

            case ')': S = Symbols.RightParenth; break;

            case '[': S = Symbols.LeftBracket; break;

            case ']': S = Symbols.RightBracket; break;

            case '{': S = Symbols.LeftBrace; break;

            case '}': S = Symbols.RightBrace; break;

            // Logical

            case '<': S = Symbols.Lesser; break;

            case '>': S = Symbols.Greater; break;

            case '!': S = Symbols.Not; break;

            // Bitwise

            case '&': S = Symbols.BitwiseAnd; break;

            case '|': S = Symbols.BitwiseOr; break;

            case '^': S = Symbols.Xor; break;

            // Language rules

            case '#': S = Symbols.Sharp; break;

            case '@': S = Symbols.At; break;

            case '$': S = Symbols.Money; break;

            case ';': S = Symbols.Semicolon; break;

            case ':': S = Symbols.Colon; break;

            case '.': S = Symbols.Dot; break;

            case ',': S = Symbols.Comma; break;

            case '~': S = Symbols.Destructor; break;

            case '?': S = Symbols.Question; break;

            case '\\': S = Symbols.InvertedBar; break;

            default: throw new Exception("Unsupported Symbol, aborting.");

        }

        CharPosition = 1;

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

    }

    private void ScanDoubleSymbol()

    {

        string Compare = CurrentChar.ToString() + NextChar.ToString();

        Symbols S;

        CharPosition = 2; // Skips this char and the next one.

        switch (Compare)

        {

            // Increment/Decrement

            case "++": S = Symbols.Increment; break;

            case "--": S = Symbols.Decrement; break;

            // Additions

            case "+=": S = Symbols.AddTo; break;

            case "-=": S = Symbols.SubTo; break;

            case "*=": S = Symbols.MulBy; break;

            case "/=": S = Symbols.DivBy; break;

            // Comparative

            case ">=": S = Symbols.GreaterEquals; break;

            case "<=": S = Symbols.LesserEquals; break;

            case "==": S = Symbols.CompEquals; break;

            case "!=": S = Symbols.NotEquals; break;

            // Linkers

            case "&&": S = Symbols.And; break;

            case "||": S = Symbols.Or; break;

            default: throw new Exception("Unsupported symbol, '" + Compare + "' aborting.");

        }

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

    }

    private void SkipComments()

    {

        while (CurrentChar != '\n')

            CharPosition = 1;

    }

    #endregion

        #region Public

        public IList<Token> Scan()

    {

        while (CharPosition < Input.Length)

        {

            if (CurrentChar == ' ' || IsLineFeed)

                CharPosition = 1; // Eats the current space/non visible character.

            else if (CurrentChar == '"')

                ScanString();

                else if (CurrentChar == '\'')

                ScanChar();

                else if (CurrentChar.IsLetter() || CurrentChar == '_')

                ScanIdentOrKeyword();

                else if (CurrentChar.IsDigit())

                ScanNumber();

                else if (IsComment)

                SkipComments();

                else if (IsDoubleSymbol)

                ScanDoubleSymbol();

                else if (CurrentChar.IsSymbol())

                ScanSymbol();

                else

                throw new Exception("Non recognized character, aborting.");

                }

        return Tokens;

    }

    // tLexer ctor, _input parameter is the content of the script/file to scan.

    public tLexer(string _input)

    {

        _input += " \n";

        _charpos = 0; // Let's initialize this.

        Tokens = new List<Token>();

        Input = _input.ToCharArray(); // Let's convert the main input into a char[].

    }

    #endregion

}

public abstract class Node

{

    public Node() { }

    public abstract object Eval();

}

​

#region Base Nodes

    public class NumberNode : Node

{

    private double Value;

    public NumberNode(double d) { Value = d; }

    public override object Eval() { return Value; }

}

public class NegNumberNode : Node

{

    private Node Value;

    public NegNumberNode(Node d) { Value = d; }

    public override object Eval() { return -(double)Value.Eval(); }

}

public class BooleanNode : Node

{

    private bool Value;

    public BooleanNode(bool v) { Value = v; }

    public override object Eval() { return Value; }

}

public class NotBooleanNode : Node

{

    private Node Value;

    public NotBooleanNode(Node v) { Value = v; }

    public override object Eval() { return !(bool)Value.Eval(); }

}

​

public class StringNode : Node

{

    private string Text;

    public StringNode(string t) { Text = t; }

    public override object Eval() { return Text; }

}

#endregion

#region Linker Node

public class LinkNode : Node

{

    private Node Left;

    private Node Right;

    private Symbols Operator;

    private bool IsForStrings()

    {

        // This checks whether is a string concatenation by "+" operator.

        return (Left.Eval().GetType() != typeof(string) && (Right.Eval().GetType() == typeof(string)))

            || (Left.Eval().GetType() == typeof(string) && (Right.Eval().GetType() != typeof(string)))

            || (Left.Eval().GetType() == typeof(string) && (Right.Eval().GetType() == typeof(string)));

    }

    public override object Eval()

    {

        object Rtn = null;

        switch (Operator)

        {

            // Arithmethical

            case Symbols.Add: 

            {   

                if (IsForStrings()) { Rtn = Left.Eval().ToString() + Right.Eval().ToString(); break; }

                Rtn = (double)Left.Eval() + (double)Right.Eval();

            } break;

            case Symbols.Sub: 

            {

                if (IsForStrings()) throw new Exception("Operator not supported for strings.");

                Rtn = (double)Left.Eval() - (double)Right.Eval();

            } break;

            case Symbols.Mul: 

            {

                if (IsForStrings()) throw new Exception("Operator not supported for strings.");

                Rtn = (double)Left.Eval() * (double)Right.Eval();

            } break;

            case Symbols.Div:

            {

                if (IsForStrings()) throw new Exception("Operator not supported for strings.");

                if ((double)Right.Eval() == 0) throw new Exception("Division by zero.");

                Rtn = (double)Left.Eval() / (double)Right.Eval();

            } break;

            case Symbols.Mod:

            {

                if (IsForStrings()) throw new Exception("Operator not supported for strings.");

                Rtn = (double)Left.Eval() % (double)Right.Eval();

            } break;

            // Comparative

            case Symbols.LesserEquals: Rtn = (double)Left.Eval() <= (double)Right.Eval(); break;

            case Symbols.Lesser: Rtn = (double)Left.Eval() < (double)Right.Eval(); break;

            case Symbols.CompEquals: Rtn = Left.Eval().Equals(Right.Eval()); break;

            case Symbols.NotEquals: Rtn = !Left.Eval().Equals(Right.Eval()); break;

            case Symbols.Greater: Rtn = (double)Left.Eval() > (double)Right.Eval(); break;

            case Symbols.GreaterEquals: Rtn = (double)Left.Eval() >= (double)Right.Eval(); break;

            // Linkers

            case Symbols.And: Rtn = (bool)Left.Eval() && (bool)Right.Eval(); break;

            case Symbols.Or: Rtn = (bool)Left.Eval() || (bool)Right.Eval(); break;

        }

        return Rtn;

    }

    public LinkNode(Symbols s, Node l, Node r)

    {

        Operator = s; Left = l; Right = r;

    }

}

#endregion

​

public class Parser

{

    #region Fields

    private int CurrentTokenPosition;

    private IList<Token> Tokens;

    private Token CurrentToken { get { try { return Tokens[CurrentTokenPosition]; } catch { return null; } } }

    private Token NextToken { get { try { return Tokens[CurrentTokenPosition + 1]; } catch { return null; } } }

    public IDictionary<string, object> SymbolsTable;

    #endregion

    #region Token Handling

    private Token MatchAndEat(object o)

    {

        if (CurrentToken.Value.Equals(o) || CurrentToken.Type.Equals(o)) { CurrentTokenPosition++; return CurrentToken; }

        else

            throw new Exception("Expected: " + o.ToString() + ", but there was: " + CurrentToken.ToString());

    }

    #region Boolean Conditions

    #endregion

    #endregion

    #region Expressions

    #region Arithmethics

    #region Numbers

    private Node Factor()

    {

        Node Rtn = null;

        if (CurrentToken.Value.Equals(Symbols.LeftParenth))

        {

            MatchAndEat(Symbols.LeftParenth);

            Rtn = Expression();

            MatchAndEat(Symbols.RightParenth);

        }

        else if (CurrentToken.Type.Equals(TokenTypes.Number))

        {

            Rtn = new NumberNode((double)CurrentToken.Value);

            MatchAndEat(TokenTypes.Number);

        }

        return Rtn;

    }

    private Node NotFactor()

    {

        if (CurrentToken.Value.Equals(Symbols.Sub)) { MatchAndEat(Symbols.Sub); return new NegNumberNode(Factor()); }  

        return Factor();

    }

    private Node Term()

    {

        Node Rtn = NotFactor();

        while (CurrentToken != null && (CurrentToken.Value.Equals(Symbols.Mul) 

           || CurrentToken.Value.Equals(Symbols.Div)

           || CurrentToken.Value.Equals(Symbols.Mod)))

        {

            switch ((Symbols)CurrentToken.Value)

            {

                case Symbols.Mul: Rtn = new LinkNode(Symbols.Mul, Rtn, Mul()); break;

                case Symbols.Div: Rtn = new LinkNode(Symbols.Div, Rtn, Div()); break;

                case Symbols.Mod: Rtn = new LinkNode(Symbols.Mod, Rtn, Mod()); break;

            }

        }

        return Rtn;

    }

    #endregion

    #region Operations

    private Node Add(){ MatchAndEat(Symbols.Add); return Term();}

    private Node Sub(){ MatchAndEat(Symbols.Sub); return Term(); }

    private Node Mul(){ MatchAndEat(Symbols.Mul); return NotFactor(); }

    private Node Div(){ MatchAndEat(Symbols.Div); return NotFactor(); }

    private Node Mod(){ MatchAndEat(Symbols.Mod); return NotFactor(); }

    #endregion

    private Node ArithExpr()

    {

        Node Rtn = Term();

        while (CurrentToken != null && (CurrentToken.Value.Equals(Symbols.Add) || CurrentToken.Value.Equals(Symbols.Sub)))

        {

            switch ((Symbols)CurrentToken.Value)

            {

                case Symbols.Add: Rtn = new LinkNode(Symbols.Add, Rtn, Add()); break;

                case Symbols.Sub: Rtn = new LinkNode(Symbols.Sub, Rtn, Sub()); break;

            }

        }

        return Rtn;

    }

    #endregion

    #region Booleans

    #region Stuff

    private Node GreaterEquals(Node l) { MatchAndEat(Symbols.GreaterEquals); return new LinkNode(Symbols.GreaterEquals, l, ArithExpr()); }

    private Node Greater(Node l) { MatchAndEat(Symbols.Greater); return new LinkNode(Symbols.Greater, l, ArithExpr()); }

    private Node Equals(Node l) { MatchAndEat(Symbols.CompEquals); return new LinkNode(Symbols.CompEquals, l, ArithExpr()); }

    private Node NotEquals(Node l) { MatchAndEat(Symbols.NotEquals); return new LinkNode(Symbols.NotEquals, l, ArithExpr()); }

    private Node Lesser(Node l) { MatchAndEat(Symbols.Lesser); return new LinkNode(Symbols.Lesser, l, ArithExpr()); }

    private Node LesserEquals(Node l) { MatchAndEat(Symbols.LesserEquals); return new LinkNode(Symbols.LesserEquals, l, ArithExpr()); }

    #endregion

    #region LAL

    private Node Relation()

    {

        Node Left = ArithExpr();

        try

        {

            switch ((Symbols)CurrentToken.Value)

            {

                case Symbols.GreaterEquals: Left = GreaterEquals(Left); break;

                case Symbols.Greater: Left = Greater(Left); break;

                case Symbols.CompEquals: Left = Equals(Left); break;

                case Symbols.NotEquals: Left = NotEquals(Left); break;

                case Symbols.Lesser: Left = Lesser(Left); break;

                case Symbols.LesserEquals: Left = LesserEquals(Left); break;

            }

        } catch {}

        return Left;

    }

    private Node BooleanFactor()

    {

        return Relation();

    }

    private Node NotBoolFactor()

    {

        if (CurrentToken.Value.Equals(Symbols.Not)) { MatchAndEat(Symbols.Not); return new NotBooleanNode(BooleanFactor()); }

        return BooleanFactor();

    }

    private Node BooleanTerm()

    {

        Node L = NotBoolFactor();

        while (CurrentToken != null && CurrentToken.Value.Equals(Symbols.Or))

        {

            switch ((Symbols)CurrentToken.Value)

            {

                case Symbols.Or: MatchAndEat(Symbols.Or); L = new LinkNode(Symbols.Or, L, BoolExpr()); break;

            }

        }

        return L;

    }

    private Node BoolExpr()

    {

        Node L = BooleanTerm();

        while (CurrentToken != null && CurrentToken.Value.Equals(Symbols.And))

        {

            switch ((Symbols)CurrentToken.Value)

            {

                case Symbols.And: MatchAndEat(Symbols.And); L = new LinkNode(Symbols.And, L, BoolExpr()); break;

            }

        }

        return L;

    }

    #endregion

    #endregion

    private Node Expression()

    {

        return BoolExpr();

    }

    #endregion

    #region Public Stuff

    public void Parse()

    {

        Node n = Expression();

        Console.WriteLine("Result: " + n.Eval());

    }

    public Parser(IList<Token> _pToks)

    {

        Tokens = new List<Token>(_pToks); // Dispose the scanner after that.

        SymbolsTable = new Dictionary<string, object>();

        CurrentTokenPosition = 0;

    }

    #endregion

}

​

​

​

​

​

​

​

​

public class Program

{

    public static void Main()

    {

        while (true) { 

        Console.Write("Type an expression> ");

        tLexer t = new tLexer(Console.ReadLine());

        foreach (Token i in t.Scan()) Console.WriteLine(i.ToString());

        Parser p = new Parser(t.Tokens);

        p.Parse(); Console.WriteLine("\n");

        }

    }

}