Masud_Sir/lexical_analyzer_plus_recursive_decent_parser.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import os\n",
    "\n",
    "\n",
    "\n",
    "CONST = [\n",
    "            'INTEGER_CONSTANT',\n",
    "            'STRING_CONSTANT', 'FLOAT_CONSTANTS', 'CHAR_CONSTANTS', 'BOOL_CONST'\n",
    "        ]\n",
    "\n",
    "TOKENS = [\n",
    "    'KEY_WORD', 'IDENTIFIER', 'INTEGER_CONSTANT',\n",
    "    'OPERATOR', 'SEPARATOR', 'STRING_CONSTANT', 'FLOAT_CONSTANTS', 'CHAR_CONSTANTS', 'DATATYPE' , 'BOOL_CONST'\n",
    "]\n",
    "blank_var = \"#include <iostream> using namespace std; void main () { if(a<b) {return i++;}else{i=0;}switch(a){case 'A': cin>>input;cout<<abcd;default: break;}}\"\n",
    "print(\"INPUT FILE:\\n\", blank_var)\n",
    "class bcolors:\n",
    "    HEADER = '\\033[95m'\n",
    "    OKBLUE = '\\033[94m'\n",
    "    OKCYAN = '\\033[96m'\n",
    "    OKGREEN = '\\033[92m'\n",
    "    WARNING = '\\033[93m'\n",
    "    FAIL = '\\033[91m'\n",
    "    ENDC = '\\033[0m'\n",
    "    BOLD = '\\033[1m'\n",
    "    UNDERLINE = '\\033[4m'\n",
    "\n",
    "\n",
    "integers = re.findall('^[0-9]+$|[0-9]+', blank_var)\n",
    "floatn = re.findall(r'[0-9]+\\.[0-9]+', blank_var)\n",
    "chars = re.findall(r'\\'[^\\'\\\\\\.]\\'', blank_var)\n",
    "\n",
    "TOKENS_DEF = {\n",
    "    '=': 'ASSIGN',\n",
    "    '&': 'ADDRESS',\n",
    "    '<': 'LT',\n",
    "    '>': 'GT',\n",
    "    '++': 'SELF_PLUS',\n",
    "    '--': 'SELF_MINUS',\n",
    "    '+': 'PLUS',\n",
    "    '-': 'MINUS',\n",
    "    '*': 'MUL',\n",
    "    '/': 'DIV',\n",
    "    '>=': 'GET',\n",
    "    '<=': 'LET',\n",
    "    '(': 'LL_BRACKET',\n",
    "    ')': 'RL_BRACKET',\n",
    "    '{': 'LB_BRACKET',\n",
    "    '}': 'RB_BRACKET',\n",
    "    '[': 'LM_BRACKET',\n",
    "    ']': 'RM_BRACKET',\n",
    "    ',': 'COMMA',\n",
    "    '\"': 'DOUBLE_QUOTE',\n",
    "    '\\'': 'SINGLE_QUOTE',\n",
    "    ';': 'SEMICOLON',\n",
    "    '#': 'SHARP',\n",
    "    '&&': 'AND',\n",
    "    '!': 'NOT',\n",
    "    '||': 'OR',\n",
    "    '<<': 'L_SHIFT',\n",
    "    '>>': 'R_SHIFT',\n",
    "    '==':'EQUALITY',\n",
    "    ':':'COLON'\n",
    "    \n",
    "}\n",
    "\n",
    "Keyword = [\"if\", \"else\", \"while\", \"for\", \"cout\", \"cin\", \"return\", \"switch\", \"case\", \"break\", \"function\",\n",
    "           \"using\", \"namespace\", \"include\", \"endl\",\"default\"]\n",
    "bracket = ['(', ')', '{', '}', '[', ']']\n",
    "datatype = ['int', 'float', 'char', 'string', 'bool','void']\n",
    "punctuator = [',', ';', ':', ',']\n",
    "arithop = ['-', '+', '*', '/', '%']\n",
    "logop = ['||', '&&']\n",
    "slogop = ['!']\n",
    "assop = ['=']\n",
    "sinlop = ['<', '>']\n",
    "relop = ['<=', '>=', '!=', '==', \"<<\", \">>\"]\n",
    "incr = ['++', '--']\n",
    "bool_cons = ['True','False']\n",
    "\n",
    "\n",
    "class Node:\n",
    "\n",
    "    # Function to initialise the node object\n",
    "    def __init__(self, value, line_numbers, type):\n",
    "        self.data = {\n",
    "            \"value\": value,\n",
    "            \"LINE_NUMBERS\": line_numbers,\n",
    "            \"TYPE\": type\n",
    "        }  # Assign data\n",
    "        self.next = None  # Initialize next as null\n",
    "\n",
    "# Node of a doubly linked list\n",
    "class Symbol_table_Node:\n",
    "    def __init__(self, name, line_numbers, type,scope):\n",
    "        self.data = {\n",
    "            \"Name\": name,\n",
    "            \"LINE_NUMBERS\": line_numbers,\n",
    "            \"TYPE\": type,\n",
    "            \"Scope\": scope\n",
    "        }  # Assign data\n",
    "        self.next = None  # Initialize next as null\n",
    "        self.prev = None\n",
    "class SymbolTable:\n",
    "    def __init__(self):\n",
    "        self.head = None\n",
    "    def push(self, name, line_numbers, type,scope):\n",
    "            new_node = Symbol_table_Node(name, line_numbers, type,scope)\n",
    "\n",
    "\n",
    "            new_node.next = self.head\n",
    "            new_node.prev = None\n",
    "\n",
    "\n",
    "            if self.head is not None:\n",
    "                self.head.prev = new_node\n",
    "\n",
    "\n",
    "            self.head = new_node\n",
    "\n",
    "    def printList(self):\n",
    "        node = self.head\n",
    "        while (node != None):\n",
    "\n",
    "            print(node.data)\n",
    "            last = node\n",
    "            node = node.next\n",
    "\n",
    "    def FindData(self, name):\n",
    "        flag = False\n",
    "        node = self.head\n",
    "\n",
    "        while (node != None):\n",
    "\n",
    "            if (node.data['Name'] == name):\n",
    "                return node.data\n",
    "            last = node\n",
    "            node = node.next\n",
    "        if (flag == False):\n",
    "            return False\n",
    "\n",
    "\n",
    "class Tokkens:\n",
    "\n",
    "    # Function to initialize head\n",
    "    def __init__(self):\n",
    "        self.head = None\n",
    "\n",
    "    # This function is defined in Linked List class\n",
    "    # Appends a new node at the end. This method is\n",
    "    # defined inside LinkedList class shown above */\n",
    "    def append(self, value, line_numbers, type):\n",
    "\n",
    "        # 1. Create a new node\n",
    "        # 2. Put in the data\n",
    "        # 3. Set next as None\n",
    "        new_node = Node(value, line_numbers, type)\n",
    "\n",
    "        # 4. If the Linked List is empty, then make the\n",
    "        # new node as head\n",
    "        if self.head is None:\n",
    "            self.head = new_node\n",
    "            return\n",
    "\n",
    "        # 5. Else traverse till the last node\n",
    "        last = self.head\n",
    "        while (last.next):\n",
    "            last = last.next\n",
    "\n",
    "        # 6. Change the next of last node\n",
    "        last.next = new_node\n",
    "\n",
    "    # Utility function to print the linked list\n",
    "    def printList(self):\n",
    "        temp = self.head\n",
    "        while (temp):\n",
    "            print(temp.data),\n",
    "            temp = temp.next\n",
    "\n",
    "class Token(object):\n",
    "\n",
    "    def __init__(self, pos, value, linenumber):\n",
    "        self.type = TOKENS_DEF[value] if (\n",
    "                pos == 3 or pos == 4\n",
    "        ) else TOKENS[pos]\n",
    "        self.value = value\n",
    "        self.line_number = linenumber\n",
    "\n",
    "class Lexer(object):\n",
    "\n",
    "    def __init__(self):\n",
    "        self.tokens = []\n",
    "        self.count = 1\n",
    "        self.temp = ''\n",
    "        self.sym = SymbolTable()\n",
    "\n",
    "    def is_blank(self, index):\n",
    "        return (\n",
    "                blank_var[index] == ' '\n",
    "        )\n",
    "\n",
    "    def is_Escape(self, index):\n",
    "        return (\n",
    "\n",
    "                blank_var[index] == '\\t' or\n",
    "                blank_var[index] == '\\n' or\n",
    "                blank_var[index] == '\\r'\n",
    "        )\n",
    "\n",
    "    def line_break(self, index):\n",
    "        return (\n",
    "                blank_var[index] == '\\n' or\n",
    "                blank_var[index] == '\\t' or\n",
    "                blank_var[index] == '\\b' or\n",
    "                blank_var[index] == ' '\n",
    "\n",
    "        )\n",
    "\n",
    "    def skip_blank(self, index, stringflag):\n",
    "        while index < len(blank_var) and self.is_blank(index):\n",
    "            index += 1\n",
    "        return index\n",
    "\n",
    "    def print_log(self, style, value):\n",
    "        print(style, value)\n",
    "\n",
    "    def checkforiden(self):\n",
    "        if (self.temp != ''):\n",
    "\n",
    "            i = re.findall('[a-zA-Z_][a-zA-Z_0-9]*', self.temp)\n",
    "\n",
    "            if (self.temp in i):\n",
    "\n",
    "                self.tokens.append(Token(1, self.temp, self.count))\n",
    "\n",
    "\n",
    "                self.sym.push(self.temp, self.count, \"NOT DEFINED\", \"NOT DEFINED\")\n",
    "                self.temp = ''\n",
    "\n",
    "\n",
    "                # symbol table code\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "            else:\n",
    "                print(\n",
    "                    f\"...{bcolors.BOLD}{bcolors.FAIL} ERROR: UNABLE TO RUN FILE {bcolors.OKBLUE} {os.path.abspath('sample.cpp')} {bcolors.FAIL} \\n INVALID IDENTIFIER IN LINE NUMBER: {self.count} {bcolors.WARNING} {self.temp} {bcolors.ENDC}\")\n",
    "\n",
    "                exit()\n",
    "                # error handler\n",
    "            self.temp = ''\n",
    "        else:\n",
    "            return 0;\n",
    "\n",
    "    def is_keyword(self, value):\n",
    "        for item in Keyword:\n",
    "            if value in item:\n",
    "                return True\n",
    "        return False\n",
    "\n",
    "    def main(self):\n",
    "        i = 0\n",
    "        strf = False\n",
    "\n",
    "        while i < len(blank_var):\n",
    "\n",
    "            if (blank_var[i] == ' '):\n",
    "                self.checkforiden()\n",
    "                i = i + 1\n",
    "                continue\n",
    "            if blank_var[i] == '\\n':\n",
    "                self.checkforiden()\n",
    "                self.count = self.count + 1\n",
    "                i = i + 1\n",
    "                continue\n",
    "            if blank_var[i] == '#':\n",
    "                self.checkforiden()\n",
    "                self.tokens.append(Token(3, blank_var[i], self.count))\n",
    "                i = i + 1\n",
    "                continue\n",
    "            elif blank_var[i:i + 2] in logop:\n",
    "                self.checkforiden()\n",
    "                self.tokens.append(Token(3, blank_var[i:i + 2], self.count))\n",
    "                i = i + 1\n",
    "            elif blank_var[i:i + 2] in relop:\n",
    "                self.checkforiden()\n",
    "                self.tokens.append(Token(3, blank_var[i:i + 2], self.count))\n",
    "                i = i + 1\n",
    "            elif blank_var[i:i + 2] in incr:\n",
    "                self.checkforiden()\n",
    "                self.tokens.append(Token(3, blank_var[i:i + 2], self.count))\n",
    "                i = i + 1\n",
    "            elif blank_var[i] in bracket:\n",
    "                self.checkforiden()\n",
    "                self.tokens.append(Token(3, blank_var[i], self.count))\n",
    "\n",
    "            elif blank_var[i] in punctuator:\n",
    "\n",
    "                self.checkforiden()\n",
    "                self.tokens.append(Token(3, blank_var[i], self.count))\n",
    "\n",
    "            elif blank_var[i] in sinlop:\n",
    "                self.checkforiden()\n",
    "                self.tokens.append(Token(3, blank_var[i], self.count))\n",
    "\n",
    "            elif blank_var[i] in assop:\n",
    "\n",
    "                self.checkforiden()\n",
    "                self.tokens.append(Token(3, blank_var[i], self.count))\n",
    "\n",
    "            elif blank_var[i] in slogop:\n",
    "                self.checkforiden()\n",
    "                self.tokens.append(Token(3, blank_var[i], self.count))\n",
    "            elif blank_var[i] in arithop:\n",
    "                self.checkforiden()\n",
    "                self.tokens.append(Token(3, blank_var[i], self.count))\n",
    "            else:\n",
    "                self.temp = self.temp + blank_var[i]\n",
    "\n",
    "                if (blank_var[i] == '\"'):\n",
    "                    #self.tokens.append(Token(3, blank_var[i], self.count))\n",
    "                    if (self.temp == '\"'):\n",
    "                        self.temp = ''\n",
    "                        i = i + 1\n",
    "                        strf = True\n",
    "                        while i < len(blank_var) and blank_var[i] != '\"':\n",
    "\n",
    "                            if (blank_var[i:i + 2] == \"\\\\t\"):\n",
    "                                self.temp = self.temp + '\\t'\n",
    "                                i = i + 2\n",
    "                            elif (blank_var[i:i + 2] == \"\\\\n\"):\n",
    "\n",
    "                                self.temp = self.temp + '\\n'\n",
    "                                i = i + 2\n",
    "                            else:\n",
    "                                self.temp = self.temp + blank_var[i]\n",
    "                                i = i + 1\n",
    "\n",
    "                            if (i == len(blank_var) or i > len(blank_var)):\n",
    "                                print(\n",
    "                                    f\"...{bcolors.BOLD}{bcolors.FAIL} ERROR: UNABLE TO RUN FILE {bcolors.OKBLUE} {os.path.abspath('sample.cpp')} {bcolors.FAIL} \\n STRING QUOTES NOT CLOSED IN LINE NUMBER: {self.count} {bcolors.WARNING} {self.temp} {bcolors.ENDC}\")\n",
    "                                exit()\n",
    "\n",
    "                        if (len(self.temp) > 0):\n",
    "                            self.tokens.append(Token(5, self.temp, self.count))\n",
    "                            strf = False\n",
    "                            self.temp = ''\n",
    "                        #self.tokens.append(Token(3, blank_var[i], self.count))\n",
    "                        i = i + 1\n",
    "                        continue\n",
    "\n",
    "                if (self.temp in integers):\n",
    "\n",
    "                    if (blank_var[i + 1] != '.' and blank_var[i+1] not in re.findall('[0-9]',blank_var)):\n",
    "\n",
    "                        j = re.findall('[a-zA-Z_][a-zA-Z_0-9]*', blank_var[i + 1]);\n",
    "\n",
    "                        if (blank_var[i + 1] not in j):\n",
    "\n",
    "                            self.tokens.append(Token(2, self.temp, self.count))\n",
    "                            integers.pop(integers.index(self.temp))\n",
    "                            \n",
    "                            self.temp = ''\n",
    "\n",
    "\n",
    "                elif (self.temp in Keyword):\n",
    "                    self.tokens.append(Token(0, self.temp, self.count))\n",
    "                    self.temp = ''\n",
    "\n",
    "\n",
    "\n",
    "                elif (self.temp in datatype):\n",
    "                    self.tokens.append(Token(8, self.temp, self.count))\n",
    "                    self.temp = ''\n",
    "\n",
    "                elif (self.temp in bool_cons):\n",
    "                \tself.tokens.append(Token(9,self.temp,self.count))\n",
    "                \tself.temp=''\n",
    "                elif (self.temp in floatn):\n",
    "                    self.tokens.append(Token(6, self.temp, self.count))\n",
    "                    self.temp = ''\n",
    "\n",
    "                if (blank_var[i] == '\\''):\n",
    "                    #self.tokens.append(Token(3, blank_var[i], self.count))\n",
    "                    self.temp = ''\n",
    "                    i = i + 1\n",
    "\n",
    "                    if (blank_var[i] == '\\''):\n",
    "                        #self.tokens.append(Token(3, blank_var[i], self.count))\n",
    "                        self.temp = ''\n",
    "                        i = i + 1\n",
    "                        continue\n",
    "                    elif (blank_var[i:i + 2] == '\\\\n' or blank_var[i:i + 2] == '\\\\t' or ord(blank_var[i])):\n",
    "                        if (blank_var[i:i + 2] == '\\\\n' or blank_var[i:i + 2 == '\\\\t']):\n",
    "                            if (blank_var[i + 2] == '\\''):\n",
    "                                self.tokens.append(Token(7, blank_var[i:i + 2], self.count))\n",
    "                                self.temp = ''\n",
    "                                i = i + 2\n",
    "                                #self.tokens.append(Token(3, blank_var[i], self.count))\n",
    "                                i = i + 1\n",
    "                                continue\n",
    "                            else:\n",
    "                                print(\n",
    "                                    f\"...{bcolors.BOLD}{bcolors.FAIL} ERROR: UNABLE TO RUN FILE {bcolors.OKBLUE} {os.path.abspath('sample.cpp')} {bcolors.FAIL} \\n CHARACTER QUOTES NOT CLOSED IN LINE NUMBER: {self.count} {bcolors.WARNING} {blank_var[i]} {bcolors.ENDC}\")\n",
    "                                exit()\n",
    "                        else:\n",
    "\n",
    "                            if (blank_var[i + 1] == '\\''):\n",
    "                                self.tokens.append(Token(7, blank_var[i], self.count))\n",
    "                                self.temp = ''\n",
    "                                i = i + 1\n",
    "                                #self.tokens.append(Token(3, blank_var[i], self.count))\n",
    "                                #i = i + 1\n",
    "                            else:\n",
    "                                print(\n",
    "                                    f\"...{bcolors.BOLD}{bcolors.FAIL} ERROR: UNABLE TO RUN FILE {bcolors.OKBLUE} {os.path.abspath('sample.cpp')} {bcolors.FAIL} \\n CHARACTER QUOTES NOT CLOSED IN LINE NUMBER: {self.count} {bcolors.WARNING} {blank_var[i]} {bcolors.ENDC}\")\n",
    "                                exit()\n",
    "\n",
    "                    else:\n",
    "                        print(\n",
    "                            f\"...{bcolors.BOLD}{bcolors.FAIL} ERROR: UNABLE TO RUN FILE {bcolors.OKBLUE} {os.path.abspath('sample.cpp')} {bcolors.FAIL} \\n CHARACTER DECLARATION NOT VALID IN LINE NUMBER: {self.count} {bcolors.WARNING} {blank_var[i]} {bcolors.ENDC}\")\n",
    "                        exit()\n",
    "\n",
    "            i = i + 1\n",
    "            continue\n",
    "\n",
    "\n",
    "class parser:\n",
    "\n",
    "    def __init__(self,tok):\n",
    "        self.tok=tok.head\n",
    "        self.lookahead=None\n",
    "\n",
    "    def nextToken(self):\n",
    "        if(self.lookahead==None):\n",
    "            return self.tok\n",
    "        else:\n",
    "            self.tok=self.tok.next\n",
    "            return self.tok\n",
    "\n",
    "    def includestmt(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        if (data == '#'):\n",
    "            self.match(\"#\")\n",
    "            self.match(\"include\")\n",
    "            self.match(\"<\")\n",
    "            self.matchID(self.lookahead.data['TYPE'])\n",
    "            self.match('>')\n",
    "        else:\n",
    "            print(\"ERROR IN INCLUDE STMT \")\n",
    "    def includelist_(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        if (data == '#'):\n",
    "            self.includestmt()\n",
    "            self.includelist_()\n",
    "        elif(data in ['$',\"using\"]):\n",
    "            return\n",
    "        else:\n",
    "            print(\"ERROR IN INCLUDE LIST _\")\n",
    "\n",
    "\n",
    "    def includelist(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        if (data == '#'):\n",
    "            self.includestmt()\n",
    "            self.includelist_()\n",
    "        else:\n",
    "            print(\"ERROR IN INCLUDE LIST\")\n",
    "\n",
    "    def namespace(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        if(data == 'using'):\n",
    "            self.match('using')\n",
    "            self.match('namespace')\n",
    "            self.matchID(self.lookahead.data[\"TYPE\"])\n",
    "            self.match(';')\n",
    "        else:\n",
    "            print(\"ERROR IN NAMESPACE\")\n",
    "    def start(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        if(data == '#'):\n",
    "            self.includelist()\n",
    "            self.namespace()\n",
    "            self.program()\n",
    "        elif(data == \"$\"):\n",
    "            return\n",
    "        else:\n",
    "            print(\"ERROR IN START\")\n",
    "\n",
    "\n",
    "\n",
    "    def vardeclist_(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        if (data == ','):\n",
    "            self.match(',')\n",
    "            self.vardecinit()\n",
    "            self.vardeclist_()\n",
    "        elif (data == ';'):\n",
    "            return\n",
    "        else:\n",
    "            print(\"ERROR IN VARRAIBLE dec list _\")\n",
    "    def vardecid(self):\n",
    "        data = self.lookahead.data['value']\n",
    "\n",
    "        if ( self.lookahead.data[\"TYPE\"]==\"IDENTIFIER\"):\n",
    "            self.matchID(self.lookahead.data[\"TYPE\"])\n",
    "            self.vardecid_()\n",
    "        else:\n",
    "            print(\"ERROR IN VARDEC ID\")\n",
    "\n",
    "    def vardecid_(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "\n",
    "        if ( data == '['):\n",
    "            self.match('[')\n",
    "            if(self.lookahead.data['TYPE']=='INTEGER_CONSTANT'):\n",
    "                self.lookahead = self.nextToken()\n",
    "                self.match(']')\n",
    "            else:\n",
    "                print(\"ERROR: NOT A CONTS\")\n",
    "        elif ( data == ',' or data == ';' or data == '='):\n",
    "            return\n",
    "        else:\n",
    "            print(\"EROR\")\n",
    "    def relop(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "\n",
    "        if( data == '<='):\n",
    "            self.match('<=')\n",
    "        elif ( data == '<'):\n",
    "            self.match('<')\n",
    "        elif ( data == '>'):\n",
    "            self.match('>')\n",
    "        elif ( data == '>='):\n",
    "            self.match('>=')\n",
    "        elif (data == '=='):\n",
    "            self.match('==')\n",
    "        elif ( data == '!='):\n",
    "            self.match('!=')\n",
    "        else:\n",
    "            print(\"ERROR IN RELOP !\")\n",
    "\n",
    "\n",
    "    def expression(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "\n",
    "        CONST = [\n",
    "            'INTEGER_CONSTANT',\n",
    "            'STRING_CONSTANT', 'FLOAT_CONSTANTS', 'CHAR_CONSTANTS', 'BOOL_CONST'\n",
    "        ]\n",
    "        data_next = self.lookahead.next\n",
    "        if (self.lookahead.data[\"TYPE\"] == \"IDENTIFIER\" and data_next.data[\"value\"] == \"++\"):\n",
    "        \tself.matchID(self.lookahead.data[\"TYPE\"])\n",
    "        \tself.match(\"++\")\n",
    "        \t\n",
    "        elif(self.lookahead.data[\"TYPE\"] == \"IDENTIFIER\" and data_next.data[\"value\"] == \"--\"):\n",
    "        \tself.matchID(self.lookahead.data[\"TYPE\"])\n",
    "        \tself.match(\"--\")\n",
    "        elif(self.lookahead.data[\"TYPE\"] == \"IDENTIFIER\" and data_next.data[\"value\"] == \"=\"):\n",
    "        \tself.matchID(self.lookahead.data[\"TYPE\"])\n",
    "        \tself.match(\"=\")\n",
    "        \tself.expression()\n",
    "        elif (data == '!' or self.lookahead.data['TYPE'] == 'IDENTIFIER'or data == '(' or self.lookahead.data['TYPE'] in CONST):\n",
    "            self.simpleExp()\n",
    "        else:\n",
    "            print(\"ERROR IN EPRESSION\")\n",
    "\n",
    "\n",
    "    def arglist_(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        if(data == ','):\n",
    "            self.match(',')\n",
    "            self.expression()\n",
    "            self.arglist_()\n",
    "        elif (data ==')'):\n",
    "            return\n",
    "        else:\n",
    "            print(\"ERROR IN ARG LIST _\")\n",
    "\n",
    "    def arglist(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        CONST = [\n",
    "            'INTEGER_CONSTANT',\n",
    "            'STRING_CONSTANT', 'FLOAT_CONSTANTS', 'CHAR_CONSTANTS', 'BOOL_CONST'\n",
    "        ]\n",
    "        if (data == '!' or self.lookahead.data['TYPE'] == 'IDENTIFIER' or data == '(' or self.lookahead.data['TYPE'] in CONST):\n",
    "            self.expression()\n",
    "            self.arglist_()\n",
    "        else:\n",
    "            print(\"ERROR IN  ARG LIST\")\n",
    "\n",
    "    def args(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "\n",
    "        CONST = [\n",
    "            'INTEGER_CONSTANT',\n",
    "            'STRING_CONSTANT', 'FLOAT_CONSTANTS', 'CHAR_CONSTANTS', 'BOOL_CONST'\n",
    "        ]\n",
    "        if (data == '!' or self.lookahead.data['TYPE'] == 'IDENTIFIER' or data == '(' or self.lookahead.data['TYPE'] in CONST):\n",
    "            self.arglist()\n",
    "        elif ( data == ')'):\n",
    "            return\n",
    "        else:\n",
    "            print(\"ERROR IN  ARGS\")\n",
    "    def constants(self):\n",
    "        data = self.lookahead.data['value']\n",
    "        CONST = [\n",
    "            'INTEGER_CONSTANT',\n",
    "            'STRING_CONSTANT', 'FLOAT_CONSTANTS', 'CHAR_CONSTANTS', 'BOOL_CONST'\n",
    "        ]\n",
    "        if(self.lookahead.data['TYPE'] in CONST):\n",
    "            self.lookahead=self.nextToken()\n",
    "        else:\n",
    "            print(\"ERROR IN CONSTANTS \")\n",
    "    def factor_(self):\n",
    "        data = self.lookahead.data['value']\n",
    "\n",
    "        if(data == '('):\n",
    "            self.match('(')\n",
    "            self.args()\n",
    "            self.match(')')\n",
    "        elif ( data == '*' or data == '/' or data == '%' or data == '+' or data == '-' or data == '<=' or data == '<' or data == '>' or data == '>=' or data == '==' or data == '!=' or data == '&&' or data==\"||\" or data == ',' or data == ';' or data == ')' or data == \"<<\"):\n",
    "            return\n",
    "        else:\n",
    "            print(\"ERROR IN FACTOR _ \" + data)\n",
    "    def factor(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        CONST = [\n",
    "            'INTEGER_CONSTANT',\n",
    "            'STRING_CONSTANT', 'FLOAT_CONSTANTS', 'CHAR_CONSTANTS', 'BOOL_CONST'\n",
    "        ]\n",
    "        if (self.lookahead.data['TYPE'] == 'IDENTIFIER'):\n",
    "            self.matchID(self.lookahead.data['TYPE'])\n",
    "            self.factor_()\n",
    "        elif (data == '('):\n",
    "            self.match('(')\n",
    "            self.expression()\n",
    "            self.match(')')\n",
    "        elif (self.lookahead.data['TYPE'] in CONST):\n",
    "            self.constants()\n",
    "        else:\n",
    "            print(\"ERROR IN  FACTOR\")\n",
    "\n",
    "\n",
    "\n",
    "    def unaryExp(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        CONST = [\n",
    "            'INTEGER_CONSTANT',\n",
    "            'STRING_CONSTANT', 'FLOAT_CONSTANTS', 'CHAR_CONSTANTS', 'BOOL_CONST'\n",
    "        ]\n",
    "        if (self.lookahead.data['TYPE'] == 'IDENTIFIER' or data == '(' or self.lookahead.data['TYPE'] in CONST):\n",
    "            self.factor()\n",
    "        else:\n",
    "            print(\"ERROR IN UNARY EXP\")\n",
    "\n",
    "    def mulOp(self):\n",
    "        data = self.lookahead.data['value']\n",
    "        if (data =='*'):\n",
    "            self.match('*')\n",
    "        elif (data=='/'):\n",
    "            self.match('/')\n",
    "        elif (data=='%'):\n",
    "            self.match('%')\n",
    "        else:\n",
    "            print(\"ERROR WITH MULOP\")\n",
    "    def mulExp_(self):\n",
    "        data = self.lookahead.data['value']\n",
    "        \n",
    "        if ( data == '*' or data == '/' or data == '%'):\n",
    "            self.mulOp()\n",
    "            self.unaryExp()\n",
    "            self.mulExp_()\n",
    "        elif ( data == '+' or data == '-' or data == '<=' or data == '<' or data == '>' or data == '>=' or data == '==' or data == '!=' or data == '&&' or data==\"||\" or data == ',' or data == ';' or data == ')' or data==\"<<\"):\n",
    "            return\n",
    "        else:\n",
    "            print(\"ERROR IN MUL EXP _\")\n",
    "    def sumOP(self):\n",
    "        data = self.lookahead.data['value']\n",
    "        if( data == '+'):\n",
    "            self.match('+')\n",
    "        elif( data == '-'):\n",
    "            self.match('-')\n",
    "        else:\n",
    "            print(\"ERROR IN SUM OP\")\n",
    "    def sumExp_(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        if (data == '+' or data == '-'):\n",
    "            self.sumOP()\n",
    "            self.mulExp()\n",
    "            self.sumExp_()\n",
    "        elif (data == '<=' or data == '<' or data == '>' or data == '>=' or data == '==' or data == '!=' or data == '&&' or data==\"||\" or data == ',' or data == ';' or data == ')' or data==\"<<\"):\n",
    "            return\n",
    "        else:\n",
    "            print(\"ERROR IN SUM EXP_\")\n",
    "    def mulExp(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        CONST = [\n",
    "            'INTEGER_CONSTANT',\n",
    "            'STRING_CONSTANT', 'FLOAT_CONSTANTS', 'CHAR_CONSTANTS', 'BOOL_CONST'\n",
    "        ]\n",
    "        if (self.lookahead.data['TYPE'] == 'IDENTIFIER' or data == '(' or self.lookahead.data['TYPE'] in CONST):\n",
    "            self.unaryExp()\n",
    "            self.mulExp_()\n",
    "        else:\n",
    "            print(\"ERROR IN SUM EXP_\")\n",
    "    def sumExp(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        CONST = [\n",
    "            'INTEGER_CONSTANT',\n",
    "            'STRING_CONSTANT', 'FLOAT_CONSTANTS', 'CHAR_CONSTANTS', 'BOOL_CONST'\n",
    "        ]\n",
    "        if (self.lookahead.data['TYPE'] == 'IDENTIFIER' or data == '(' or self.lookahead.data['TYPE'] in CONST):\n",
    "            self.mulExp()\n",
    "            self.sumExp_()\n",
    "        else:\n",
    "            print(\"ERROR IN SUM EXP\")\n",
    "    def relExp_(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        if (data == '<=' or data == '<' or data == '>' or data == '>=' or data == '==' or data == '!='):\n",
    "            self.relop()\n",
    "            self.sumExp()\n",
    "            self.relExp_()\n",
    "        elif (data == '||' or data == '&&' or data ==',' or data == ';' or data == ')' or data==\"<<\"):\n",
    "            return\n",
    "        else:\n",
    "            print(\"ERROR IN REL EXP !\")\n",
    "    def relExp(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        CONST = [\n",
    "            'INTEGER_CONSTANT',\n",
    "            'STRING_CONSTANT', 'FLOAT_CONSTANTS', 'CHAR_CONSTANTS', 'BOOL_CONST'\n",
    "        ]\n",
    "        if (self.lookahead.data['TYPE'] == 'IDENTIFIER' or data == '(' or self.lookahead.data['TYPE'] in CONST):\n",
    "            self.sumExp()\n",
    "            self.relExp_()\n",
    "        else:\n",
    "            print(\"ERROR IN REL EXP !\")\n",
    "    def unaryRelExp(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        CONST = [\n",
    "            'INTEGER_CONSTANT',\n",
    "            'STRING_CONSTANT', 'FLOAT_CONSTANTS', 'CHAR_CONSTANTS', 'BOOL_CONST'\n",
    "        ]\n",
    "        if (data == '!'):\n",
    "            self.match('!')\n",
    "            self.unaryRelExp()\n",
    "        elif (self.lookahead.data['TYPE'] == 'IDENTIFIER' or data == '(' or self.lookahead.data['TYPE'] in CONST ):\n",
    "            self.relExp()\n",
    "        else:\n",
    "            print(\"ERROR IN UNARY REL EXP\")\n",
    "\n",
    "\n",
    "    def andExp_(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        if( data == '&&'):\n",
    "            self.match(\"&&\")\n",
    "            self.unaryRelExp()\n",
    "            self.andExp_()\n",
    "        elif (data == '||' or data == ',' or data == ';' or data == ')' or data == \"<<\"):\n",
    "            return\n",
    "        else:\n",
    "            print(\"ERROR IN AND EXP _\")\n",
    "    def andExp(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        CONST = [\n",
    "            'INTEGER_CONSTANT',\n",
    "            'STRING_CONSTANT', 'FLOAT_CONSTANTS', 'CHAR_CONSTANTS', 'BOOL_CONST'\n",
    "        ]\n",
    "        if (data == '!' or self.lookahead.data['TYPE'] == 'IDENTIFIER' or data == '(' or self.lookahead.data['TYPE'] in CONST):\n",
    "            self.unaryRelExp()\n",
    "            self.andExp_()\n",
    "        else:\n",
    "            print(\"ERROR IN and EXP\")\n",
    "\n",
    "    def SimpleExp_(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        if ( data == '||'):\n",
    "            self.match('||')\n",
    "            self.andExp()\n",
    "            self.SimpleExp_()\n",
    "        elif (data == ',' or data == ';' or data == ')' or data == \"<<\"):\n",
    "            return\n",
    "        else:\n",
    "            print(\"ERROR IN SIMPLE EXP _\")\n",
    "    def simpleExp(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        CONST = [\n",
    "            'INTEGER_CONSTANT',\n",
    "            'STRING_CONSTANT', 'FLOAT_CONSTANTS', 'CHAR_CONSTANTS', 'BOOL_CONST'\n",
    "        ]\n",
    "        if(data == '!' or self.lookahead.data['TYPE'] == 'IDENTIFIER' or  data == '(' or self.lookahead.data['TYPE'] in CONST):\n",
    "            self.andExp()\n",
    "            self.SimpleExp_()\n",
    "        else:\n",
    "            print(\"ERROR IN SIMPLE EXP\")\n",
    "\n",
    "\n",
    "    def vardecinit_(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "\n",
    "        if(data == '='):\n",
    "            self.match('=')\n",
    "            self.simpleExp()\n",
    "        elif(data == ',' or data == ';' ):\n",
    "            return\n",
    "        else:\n",
    "            print(\"ERROR IN VARDECINIT_\")\n",
    "\n",
    "    def vardecinit(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "\n",
    "        if (self.lookahead.data[\"TYPE\"] == \"IDENTIFIER\"):\n",
    "            self.vardecid()\n",
    "            self.vardecinit_()\n",
    "        else:\n",
    "            print(\"ERROR IN VARRAIBLE INIT\")\n",
    "\n",
    "    def vardeclist(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "\n",
    "        if (self.lookahead.data[\"TYPE\"] == \"IDENTIFIER\"):\n",
    "            self.vardecinit()\n",
    "            self.vardeclist_()\n",
    "        else:\n",
    "            print(\"ERROR IN VARRAIBLE DECLIST\")\n",
    "\n",
    "    def varriable(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "\n",
    "        if(self.lookahead.data[\"TYPE\"] == \"IDENTIFIER\"):\n",
    "            self.vardeclist()\n",
    "            self.match(';')\n",
    "        else:\n",
    "            print(\"ERROR IN VARRAIBLE ONLY\")\n",
    "\n",
    "    def declaration__(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        data_next = self.lookahead.next\n",
    "        if (self.lookahead.data['TYPE'] == \"IDENTIFIER\" and data_next.data['value'] == '('):\n",
    "            self.function()\n",
    "        elif (self.lookahead.data['TYPE'] == \"IDENTIFIER\"):\n",
    "            self.varriable()\n",
    "        else:\n",
    "            print(\"ERROR IN DELARATION__\")\n",
    "    def declaration(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "\n",
    "        if (data in datatype):\n",
    "            self.typeid()\n",
    "            self.declaration__()\n",
    "        else:\n",
    "            print(\"ERROR:  IN declaration FUNCTION\")\n",
    "    def declaration_(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "\n",
    "        if (data in datatype):\n",
    "            self.declaration()\n",
    "            self.declaration_()\n",
    "        elif (data == '$'):\n",
    "            return\n",
    "        else:\n",
    "            print(\"ERROR:  IN declaration_ FUNCTION\")\n",
    "\n",
    "    def declist(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "\n",
    "        if (data in datatype):\n",
    "            self.declaration()\n",
    "            self.declaration_()\n",
    "        else:\n",
    "            print(\"ERROR:  IN declist FUNCTION\")\n",
    "\n",
    "    def program(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "\n",
    "        if ( data in datatype):\n",
    "            self.declist()\n",
    "        elif (data == '$'):\n",
    "            return\n",
    "        else:\n",
    "            print(\"ERROR:  IN PROGRAM FUNCTION\")\n",
    "    def function(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        if(self.lookahead.data['TYPE'] == 'IDENTIFIER'):\n",
    "            self.matchID(self.lookahead.data['TYPE'])\n",
    "            self.match('(')\n",
    "            self.paramas()\n",
    "            self.match(')')\n",
    "            self.match('{')\n",
    "            self.stmtlist()\n",
    "            self.match('}')\n",
    "        elif(data == '$'):\n",
    "            return\n",
    "        else:\n",
    "            print(\"ERROR IN FUNCTION SYNTAX TOKEN: \",self.lookahead.data)\n",
    "            exit()\n",
    "    def stmtlist(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        \n",
    "        CONST = [\n",
    "            'INTEGER_CONSTANT',\n",
    "            'STRING_CONSTANT', 'FLOAT_CONSTANTS', 'CHAR_CONSTANTS', 'BOOL_CONST'\n",
    "        ]\n",
    "        if(data in ['!','(','if','cout','cin','while','for','switch','return','break'] or data in datatype or self.lookahead.data[\"TYPE\"] in [\"IDENTIFIER\" , CONST]):\n",
    "            self.statment()\n",
    "            self.stmtlist_()\n",
    "        else:\n",
    "            print(\"ERROR IN STMTLIST\")\n",
    "    def iteration(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        if(data == 'for'):\n",
    "            self.match('for')\n",
    "            self.match('(')\n",
    "            self.vardecinit()\n",
    "            self.match(';')\n",
    "            self.simpleExp()\n",
    "            self.match(';')\n",
    "            self.expression()\n",
    "            self.match(')')\n",
    "            self.match('{')\n",
    "            self.stmtlist()\n",
    "            self.match('}')\n",
    "        elif(data == \"while\"):\n",
    "        \tself.match(\"while\")\n",
    "        \tself.match(\"(\")\n",
    "        \tself.simpleExp()\n",
    "        \tself.match(\")\")\n",
    "        \tself.match(\"{\")\n",
    "        \tself.stmtlist()\n",
    "        \tself.match(\"}\")\n",
    "        else:\n",
    "            print('ERROR IN ITERETION')\n",
    "    def switch(self):\n",
    "    \tdata=self.lookahead.data[\"value\"]\n",
    "    \tif(data ==\"switch\"):\n",
    "    \t\tself.match(\"switch\")\n",
    "    \t\tself.match(\"(\")\n",
    "    \t\tself.simpleExp()\n",
    "    \t\tself.match(\")\")\n",
    "    \t\tself.match(\"{\")\n",
    "    \t\tself.caselist()\n",
    "    \t\tself.default()\n",
    "    \t\tself.match(\"}\")\n",
    "    \telse:\n",
    "    \t\tprint(\"Error in SWITCH\")\n",
    "    def caselist(self):\n",
    "    \tdata = self.lookahead.data[\"value\"]\n",
    "    \tif(data==\"case\"):\n",
    "    \t\tself.onecase()\n",
    "    \t\tself.caselist()\n",
    "    \telif(data==\"default\" or data == \"}\"):\n",
    "    \t\treturn\n",
    "    \telse:\n",
    "    \t\tprint(\"ERROR IN CASELIST\")\n",
    "    \t\t\n",
    "    def onecase(self):\n",
    "    \t\tdata = self.lookahead.data[\"value\"]\n",
    "    \t\tif(data==\"case\"):\n",
    "    \t\t\tself.match(\"case\")\n",
    "    \t\t\tif(self.lookahead.data[\"TYPE\"] in CONST):\n",
    "    \t\t\t\tself.lookahead =self.nextToken()\n",
    "    \t\t\t\tself.match(\":\")\n",
    "    \t\t\t\tself.stmtlist()\n",
    "    \t\t\telse:\n",
    "    \t\t\t\tprint(\"ERROR IN CONSTANTS IN SWITCH CASE\")\n",
    "    \t\telse: \n",
    "    \t\t     print(\"ERROR IN ONE CASE\")\n",
    "    \t\t\n",
    "    \t \t\n",
    "    def default(self):\n",
    "    \tdata=self.lookahead.data[\"value\"]\n",
    "    \tif(data == \"default\"):\n",
    "    \t\tself.match(\"default\")\n",
    "    \t\tself.match(\":\")\n",
    "    \t\tself.stmtlist()\n",
    "    \telif(data == \"}\"):\n",
    "    \t\treturn\n",
    "    \telse:\n",
    "    \t\tprint(\"ERROR IN DEFAULT\")\n",
    "    def selection(self):\n",
    "    \tdata =self.lookahead.data[\"value\"]\n",
    "    \tif(data == \"if\"):\n",
    "    \t\tself.match(\"if\")\n",
    "    \t\tself.match(\"(\")\n",
    "    \t\tself.simpleExp()\n",
    "    \t\tself.match(\")\")\n",
    "    \t\tself.match(\"{\")\n",
    "    \t\tself.stmtlist()\n",
    "    \t\tself.match(\"}\")\n",
    "    \t\tself.selection_()\n",
    "    \telse:\n",
    "    \t\tprint(\"ERROR IN SELECTION: \"+data)\n",
    "    def selection_(self):\n",
    "    \tdata = self.lookahead.data[\"value\"]\n",
    "    \tif(data == \";\"):\n",
    "    \t\tself.match(\";\")\n",
    "    \telif(data ==\"else\"):\n",
    "    \t\tself.match(\"else\")\n",
    "    \t\tself.match(\"{\")\n",
    "    \t\tself.stmtlist()\n",
    "    \t\tself.match(\"}\")\n",
    "    \telse:\n",
    "    \t\tprint(\"ERROR IN IF CONDITION: TOKEN \"+data)\n",
    "    \t\texit()\n",
    "    \n",
    "    def statment(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        if(data in ['for','while']):\n",
    "            self.iteration()\n",
    "        elif(data in ['return']):\n",
    "            self.returnstmt()\n",
    "        elif(data in ['if']):\n",
    "            self.selection()\n",
    "        elif(data in ['switch']):\n",
    "            self.switch()\n",
    "        elif(data in ['break']):\n",
    "            self.match(\"break\")\n",
    "            self.match(\";\")\n",
    "        elif(data == \"continue\"):\n",
    "        \tself.match(\"continue\")\n",
    "        \tself.match(\";\")\n",
    "        elif(data in [\"cin\",\"cout\"]):\n",
    "        \tself.input_output()\n",
    "        elif(data in datatype):\n",
    "            self.declaration()\n",
    "        elif (data in ['!','('] or self.lookahead.data[\"TYPE\"] in [\"IDENTIFIER\", CONST]):\n",
    "            self.expression()\n",
    "            self.match(\";\")\n",
    "        else:\n",
    "            print(\"ERROR IN STATEMENT\")\n",
    "\n",
    "    def printlist(self):\n",
    "    \tdata= self.lookahead.data[\"value\"]\n",
    "    \tif(data == \"<<\"):\n",
    "    \t\tself.single()\n",
    "    \t\tself.printlist_()\n",
    "    \telse:\n",
    "    \t\tprint(\"ERROR IN PRINTLIST :\")\n",
    "    def single(self):\n",
    "    \tdata=self.lookahead.data[\"value\"]\n",
    "    \tif(data == \"<<\"):\n",
    "    \t\tself.match(\"<<\")\n",
    "    \t\tself.expression()\n",
    "    \telse:\n",
    "    \t\tprint(\"ERROR IN SINGLE: \")\n",
    "    def printlist_(self):\n",
    "    \tdata =self.lookahead.data[\"value\"]\n",
    "    \tdata_next = self.lookahead.next\n",
    "    \tif(data == \"<<\" and data_next.data[\"value\"] not in [\"endl\"]):\n",
    "    \t\tself.single()\n",
    "    \t\tself.printlist_()\n",
    "    \telif(data == \"<<\" or data == \";\" ):\n",
    "    \t\treturn \n",
    "    \telse:\n",
    "    \t\tprint(\"ERROR IN PRINTLIST_\")\n",
    "    def endstmt(self):\n",
    "    \tdata = self.lookahead.data[\"value\"]\n",
    "    \tif(data == \"<<\"):\n",
    "    \t\tself.match(\"<<\")\n",
    "    \t\tself.match(\"endl\")\n",
    "    \t\tself.match(\";\")\n",
    "    \telif(data == \";\"):\n",
    "    \t\tself.match(\";\")\n",
    "    \telse:\n",
    "    \t\tprint(\"ERROR IN ENDSTMT\")\n",
    "    def input_output(self):\n",
    "    \tdata = self.lookahead.data[\"value\"]\n",
    "    \tif(data == \"cout\"):\n",
    "    \t\tself.match(\"cout\")\n",
    "    \t\tself.printlist()\n",
    "    \t\tself.endstmt()\n",
    "    \telif(data == \"cin\"):\n",
    "    \t\tself.match(\"cin\")\n",
    "    \t\tself.inputlist()\n",
    "    \t\tself.match(\";\")\n",
    "    \telse:\n",
    "    \t\tprint(\"ERROR IN INPUT_OUTPUT TOKEN: \"+self.lookahead.data)\n",
    "    def inputlist(self):\n",
    "    \tdata = self.lookahead.data[\"value\"]\n",
    "    \tif(data == \">>\"):\n",
    "    \t\tself.singleinput()\n",
    "    \t\tself.inputlist_()\n",
    "    \telse:\n",
    "    \t\tprint(\"ERROR IN INPUTLIST\")\n",
    "    def inputlist_(self):\n",
    "    \tdata = self.lookahead.data[\"value\"]\n",
    "    \tif(data==\">>\"):\n",
    "    \t\tself.singleinput()\n",
    "    \t\tself.inputlist_()\n",
    "    \telif(data == \";\"):\n",
    "    \t\treturn;\n",
    "    \telse:\n",
    "    \t\tprint(\"ERROR IN INPUTLIST_\")\n",
    "    def singleinput(self):\n",
    "    \tdata=self.lookahead.data[\"value\"]\n",
    "    \tif(data == \">>\"):\n",
    "    \t\tself.match(\">>\")\n",
    "    \t\tself.matchID(self.lookahead.data[\"TYPE\"])\n",
    "    \telse:\n",
    "    \t\tprint(\"ERROR IN SINGLEINPUT:\")\n",
    "    def stmtlist_(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "\n",
    "        if (data in ['!', '(','cout','cin','if', 'while', 'for', 'switch', 'return', 'break'] or data in datatype or self.lookahead.data[\"TYPE\"] in [\"IDENTIFIER\", CONST]):\n",
    "            self.statment()\n",
    "            self.stmtlist_()\n",
    "        elif(data in ['}'] or data == \"default\"):\n",
    "            return\n",
    "        else:\n",
    "            print(\"ERROR IN STMTLIST_\" + data)\n",
    "\n",
    "    def returnstmt(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        if(data == 'return'):\n",
    "            self.match('return')\n",
    "            self.expression()\n",
    "            self.match(';')\n",
    "        elif(data == '}'):\n",
    "            return\n",
    "        else:\n",
    "            print(\"ERROR IN STATEMENT: \",self.lookahead.data)\n",
    "            exit()\n",
    "    def data(self):\n",
    "        value = self.lookahead.data['TYPE'];\n",
    "        data = self.lookahead.data['value'];\n",
    "        conslist = ['INTEGER_CONSTANT','STRING_CONSTANT', 'FLOAT_CONSTANTS', 'CHAR_CONSTANTS','BOOL_CONST']\n",
    "        if(value in conslist):\n",
    "            self.lookahead = self.nextToken()\n",
    "\n",
    "        elif (data == ';'):\n",
    "            return\n",
    "        else:\n",
    "            print(\"ERROR IN RETURN DATA: \",self.lookahead.data)\n",
    "            exit()\n",
    "    def paramas(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        if (data in datatype):\n",
    "            self.paralist()\n",
    "        elif (data == ')'):\n",
    "            return\n",
    "        else:\n",
    "            print(\"ERROR WITH PARAMETERS: \",self.lookahead.data)\n",
    "            exit()\n",
    "    def paralist(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        if(data in datatype):\n",
    "            self.parameter()\n",
    "            self.paralist_()\n",
    "        else:\n",
    "            print(\"ERROR WITH PARALIST: \", self.lookahead.data)\n",
    "            exit()\n",
    "    def paralist_(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        if(data == ','):\n",
    "            self.match(',')\n",
    "            self.parameter()\n",
    "            self.paralist_()\n",
    "        elif(data == ')'):\n",
    "            return\n",
    "        else:\n",
    "            print(\"ERROR WITH PARALIST_: \", self.lookahead.data)\n",
    "            exit()\n",
    "    def parameter(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        if( data in datatype):\n",
    "            self.vartypeid()\n",
    "            self.paraid()\n",
    "        else:\n",
    "            print(\"ERROR WITH PARAMETERS: \", self.lookahead.data)\n",
    "            exit()\n",
    "    def paraid(self):\n",
    "        type = self.lookahead.data['TYPE'];\n",
    "        if(type == 'IDENTIFIER'):\n",
    "            self.matchID(type)\n",
    "            self.paraid_()\n",
    "        else:\n",
    "            print(\"ERROR IN PARAMETERS IDENTIFIER: \",self.lookahead.data)\n",
    "            exit()\n",
    "    def paraid_(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        if(data == '['):\n",
    "            self.match('[')\n",
    "            self.match(']')\n",
    "        elif (data == ')' or data == ','):\n",
    "            return\n",
    "        else:\n",
    "            print(\"ERROR IN PARAMETERS IDENTIFIER: \", self.lookahead.data)\n",
    "            exit()\n",
    "\n",
    "    def match(self,t):\n",
    "        if(self.lookahead.data['value'] == t):\n",
    "            self.lookahead= self.nextToken()\n",
    "\n",
    "        else:\n",
    "            print(\"ERROR WITH SYNATX NEAR TOKKEN: \",self.lookahead.data['value'] , \" IN LINE NUMBER: \", self.lookahead.data['LINE_NUMBERS'])\n",
    "            exit()\n",
    "    def matchID(self,type):\n",
    "\n",
    "        if(type=='IDENTIFIER'):\n",
    "            self.lookahead = self.nextToken()\n",
    "        else:\n",
    "            print(\"ERROR IN TOKEN: \" , self.lookahead.data)\n",
    "            print(\"EXPECTED TO BE IDENTIFIER ...\")\n",
    "            exit()\n",
    "\n",
    "    def typeid(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        type = self.lookahead.data['TYPE'];\n",
    "        if(data == 'int'):\n",
    "            self.match('int')\n",
    "        elif(data == 'float'):\n",
    "            self.match('float')\n",
    "        elif(data == 'string'):\n",
    "            self.match('string')\n",
    "        elif(data == 'char'):\n",
    "            self.match('char')\n",
    "        elif(data == 'bool'):\n",
    "            self.match('bool')\n",
    "        elif (data == 'void'):\n",
    "            self.match('void')\n",
    "        else:\n",
    "            print(\"ERROR WITH TYPE IN TOKEN: \" , self.lookahead.data)\n",
    "            exit()\n",
    "\n",
    "    def vartypeid(self):\n",
    "        data = self.lookahead.data['value'];\n",
    "        type = self.lookahead.data['TYPE'];\n",
    "        if (data == 'int'):\n",
    "            self.match('int')\n",
    "        elif (data == 'float'):\n",
    "            self.match('float')\n",
    "        elif (data == 'string'):\n",
    "            self.match('string')\n",
    "        elif (data == 'char'):\n",
    "            self.match('char')\n",
    "        elif (data == 'bool'):\n",
    "            self.match('bool')\n",
    "        else:\n",
    "            print(\"ERROR WITH TYPE IN TOKEN: \", self.lookahead.data)\n",
    "            exit()\n",
    "\n",
    "\n",
    "def lexer():\n",
    "    lexer = Lexer()\n",
    "    lexer.main()\n",
    "    tok = Tokkens()\n",
    "    for token in lexer.tokens:\n",
    "        tok.append(token.value, token.line_number, token.type)\n",
    "    tok.append('$', token.line_number + 1, \"EOF\")\n",
    "    tok.printList()\n",
    "    #print(\"\\nSYMBOL TABLE: \\n\")\n",
    "    #lexer.sym.printList()\n",
    "    #print(\"\\n\")\n",
    "    check = parser(tok)\n",
    "    check.lookahead = check.nextToken()\n",
    "    check.start()\n",
    "\n",
    "\n",
    "    if check.lookahead.data['value']  == '$':\n",
    "        print(\"SYNTAX IS CORRECT... \")\n",
    "\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    lexer()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}