/** This class serve as the Parser and is currently implementing the Recursive Descent Algorithm

 * Date of Creation: 04/04/2024 12:00 PM     and     Date of Submission: 04/06/2024 1:30 PM

 * 3CS-A

 * Austria, Nelson Gabriel B.

 * Mendoza, Joshua E.

 */

​

​

using System;

using System.Text.RegularExpressions;

using System.Collections;

using System.Collections.Generic;

​

class Program

{

    static void Main(string[] args)

    {

​

        String response = null;

        List<Tokenizer.Token> tokenList;

​

        try

        {

            while (response != "exit")

            {

                Console.WriteLine("Enter the Code");

                var code = Console.ReadLine();

                // Console.WriteLine(code);

​

                tokenList = Tokenizer.Tokenize(code);

                if (Parser.Parse(tokenList))

                {

                    Console.WriteLine("Valid Statement");

                }

                else

                {

                    Console.WriteLine("Invalid Statement");

                }

​

                Console.WriteLine("Enter [exit] to close the Program or...");

                Console.WriteLine("enter anything else to continue");

                response = Console.ReadLine();

​

            }

        }

        catch (Exception er)

        {

            Console.WriteLine("Invalid Input");

            Console.WriteLine(er);

        }

​

​

    }

}

​

​

​

class Tokenizer

{

​

    public static List<Token> tokenList = new List<Token>();

​

​

    public class Token

    {

        public TokenType type;

        public String value;

​

        public Token(String value, TokenType type)

        {

            this.value = value;

            this.type = type;

        }

    }

​

    static HashSet<string> dataTypes = new HashSet<string>() {"var", "byte", "short", "int", "long",

             "float", "double", "boolean", "char"};

​

    static readonly Regex varRegex = new(@"^\w+$");

​

​

​

    public enum TokenType

    {

        DATATYPE,

​

        IDENTIFIER,

        ARRAY,

        NEW,

​

        NUMERIC_LITERAL,

        FLOAT_LITERAL,

        CHAR_LITERAL,

        BOOLEAN_LITERAL,

​

        ADDITION_OPERATOR,

        SUBTRACTION_OPERATOR,

        MULTIPLICATION_OPERATOR,

        DIVISION_OPERATOR,

​

        EQUAL_SIGN,

​

        CLOSE_CURLY_BRACKETS,

        OPEN_CURLY_BRACKETS,

        CLOSE_BRACKETS,

        OPEN_BRACKETS,

​

        CLOSE_PARENTHESIS,

        OPEN_PARENTHESIS,

​

        PUNCTUATION,

        OPERATOR,

        UNKNOWN

    }

​

    public static List<Token> Tokenize(string input)

    {

        char[] delimiters = { ' ', '(', ')', '/', '*', '+', '-' };

​

        String[] inputList = input.Split(delimiters);

​

        foreach (String inp in inputList)

        {

            tokenList.Add(new Token(inp, GetTokenType(inp)));

        }

​

        return tokenList;

    }

​

    static TokenType GetTokenType(String value)

    {

        if (value.Equals('+'))

        {

            return TokenType.ADDITION_OPERATOR;

        }

​

        else if (value.Equals('-'))

        {

            return TokenType.SUBTRACTION_OPERATOR;

        }

​

        else if (value.Equals('*'))

        {

            return TokenType.MULTIPLICATION_OPERATOR;

        }

​

        else if (value.Equals('/'))

        {

            return TokenType.DIVISION_OPERATOR;

        }

​

        else if (int.TryParse(value, out _))

        {

            return TokenType.NUMERIC_LITERAL;

        }

​

        else if (dataTypes.Contains(value))

        {

            return TokenType.DATATYPE;

        }

​

        else if (varRegex.IsMatch(value))

        {

            return TokenType.IDENTIFIER;

        }

​

        return TokenType.UNKNOWN;

    }

}

​

​

namespace FinalsAct1;

​

class Parser

{

    static int currentTokenIndex = 0;

    static Tokenizer.Token? currentToken;

​

    static List<Tokenizer.Token>? _tokenList;

​

    //Statement Type Swithes

    static bool isValid = false;

    static bool isDeclaration = false;

    static bool isInitialization = false;

​

    public static bool Parse(List<Tokenizer.Token> tokenList)

    {

        currentToken = tokenList[currentTokenIndex];

        _tokenList = tokenList;

​

        // foreach (Tokenizer.Token token in tokenList)

        // {

        //     Console.WriteLine("TokenType: {0} and Value: {1}", token.type, token.value);

        // }

        if (isDeclaration || isInitialization)

        {

            return true;

        }

        return false;

​

    }

​

    //Utility Methods

    static bool match(string expectedValue)

    {

        if (currentToken?.value == expectedValue)

        {

            consume();

            return true;

        }

        consume();

        return false;

    }

    static bool match(Tokenizer.TokenType expectedType)

    {

        if (currentToken?.type == expectedType)

        {

            consume();

            return true;

        }

        consume();

        return false;

    }

​

    static void consume()

    {

        if (currentTokenIndex < _tokenList?.Count)

        {

            currentTokenIndex++;

            currentToken = _tokenList[currentTokenIndex];

        }

​

    }

​

​

​

    //Recusive Methods

    static bool ParseStatement()

    {

        if (ParseInitialization())

        {

            isValid = true;

            return true;

        }

        return false;

    }

​

    static bool ParseDeclaration()

    {

        if (match(Tokenizer.TokenType.DATATYPE) && match(Tokenizer.TokenType.IDENTIFIER))

        {

            isDeclaration = true;

            return true;

        }

        return false;

    }

​

    static bool ParseInitialization()

    {

        if (ParseDeclaration() && match("=") && ParseExpression())

        {

            isInitialization = true;

            return true;

        }

        return false;

    }

​

    static bool ParseExpression()

    {

        while (currentToken?.value != ";")

        {

​

        }

        return false;

    }

​

​

}

​