Upload 25 files

Digit_Fifth_Power.txt

@@ -0,0 +1,30 @@
+BEGIN
+    sum := 0;
+    FOR i := 2; i <= 3720087; i := i + 1
+    DO
+        BEGIN
+            newsum := 0;
+            reduce := i;
+            WHILE reduce > 0
+            DO
+                BEGIN
+                    digit := reduce%10;
+                    reduce := reduce/10;
+                    PRINT reduce END;
+                    power := 1;
+                    FOR j := 1; j <= 5; j := j + 1
+                    DO
+                        BEGIN
+                            power := power * digit;
+                        END
+                    END;
+                    newsum := newsum + power;
+                END
+            END;
+            IF newsum = i
+                THEN sum := sum + i
+                ELSE END;
+        END
+    END;
+PRINT sum END;
+END

IncrementDecrement_testcases.txt

@@ -0,0 +1,16 @@
+
+{1. Increment and Decrement}
+BEGIN
+    i := 10;
+    PRINT i END;
+    INC(i);
+    PRINT i END;
+    DEC(i);
+    PRINT i END;
+    DEC(i);
+    PRINT i END;
+    PRINT "...." END;
+    PRINT END;
+    PRINT "...." END;
+END
+

Parser.py

@@ -0,0 +1,677 @@
+from dataclasses import dataclass
+import sys
+
+from lexer import *
+# import sim 
+from dataclasses_sim import *
+
+@dataclass
+class Parser(object):
+    def __init__(self, lexer):
+        self.lexer = lexer
+        self.curr_token = self.lexer.get_token()
+        self.lexer.lineNum = 0
+
+    def check_type(self, Type):
+        if self.curr_token.type == Type:
+            self.curr_token = self.lexer.get_token()
+        else:
+            print("Expected Token Type: ", Type)
+            print("Got Token: ", self.curr_token)
+            print("At line number:", self.lexer.lineNum)
+            print(self.lexer.curLine)
+            print(" "*(self.lexer.curLinePos-1),"^")
+            sys.exit('Invalid character')
+
+
+
+    def parse_if(self):
+        
+        self.check_type(IF)
+        condition = self.logical()
+        self.check_type(THEN)
+        if self.curr_token.type != BEGIN and self.curr_token.type != IF and self.curr_token.type != WHILE and self.curr_token.type != FOR and self.curr_token.type != FUNCTION:
+            true = self.parse()
+            self.check_type(SEMI)
+        else:    
+            true = self.parse()
+        self.check_type(ELSE)
+        while self.curr_token.type == IF:
+            self.check_type(IF)
+            condition = self.logical()
+            self.check_type(THEN)
+            if self.curr_token.type != BEGIN and self.curr_token.type != IF and self.curr_token.type != WHILE and self.curr_token.type != FOR and self.curr_token.type != FUNCTION:
+                true = self.parse()
+                self.check_type(SEMI)
+            else:    
+                true = self.parse()
+            self.check_type(ELSE)
+        if self.curr_token.type != END:
+            if self.curr_token.type != BEGIN and self.curr_token.type != IF and self.curr_token.type != WHILE and self.curr_token.type != FOR and self.curr_token.type != FUNCTION:
+                false = self.parse()
+                self.check_type(SEMI)
+            else:
+                false = self.parse()
+        else:
+            false = None
+        self.check_type(END)
+        node = IfElse(condition, true, false)
+        return node     
+    
+
+    def parse_begin(self):
+        """parse_begin : """
+        self.check_type(BEGIN)
+        if self.curr_token.type == END:
+            self.check_type(END)
+            return Seq([])
+        # s = self.parse_list()
+        ignoreSEMI = False
+        if self.curr_token.type == IF or self.curr_token.type == WHILE or self.curr_token.type == FOR or self.curr_token.type == FUNCTION or self.curr_token.type == BEGIN:
+            ignoreSEMI = True
+        e = self.parse()
+        token = self.curr_token
+        Type = token.type
+        seq = [e]
+        
+        while Type != END:
+            if not ignoreSEMI:
+                self.check_type(SEMI)
+            ignoreSEMI = False
+            if self.curr_token.type == END:
+                break
+            if self.curr_token.type == IF or self.curr_token.type == WHILE or self.curr_token.type == FOR or self.curr_token.type == FUNCTION or self.curr_token.type == BEGIN:
+                ignoreSEMI = True
+            e = self.parse()
+            
+            seq.append(e)
+            token = self.curr_token
+            Type = token.type
+        
+        # if Type == SEMI: 
+        #     self.check_type(SEMI)
+        self.check_type(END)
+        return Seq(seq)
+        # return s
+    
+    def parse_for(self):
+        self.check_type(FOR)
+        start = self.parse()
+        # print("Hi", start)
+        self.check_type(SEMI)
+        condition = self.logical()
+        # print("Hi2", end)
+        self.check_type(SEMI)
+        increment = self.parse()
+        # print("Hi3",jump)
+        self.check_type(DO)
+        if self.curr_token.type != BEGIN and self.curr_token.type != IF and self.curr_token.type != WHILE and self.curr_token.type != FOR and self.curr_token.type != FUNCTION:
+            body = self.parse()
+            self.check_type(SEMI)
+            self.check_type(END)
+            return ForLoop(start, condition, increment, body)
+        body = self.parse()
+        self.check_type(END)
+        return ForLoop(start, condition, increment, body)
+    
+    def parse_while(self):
+        self.check_type(WHILE)
+        c = self.logical()
+        self.check_type(DO)
+        if self.curr_token.type != BEGIN and self.curr_token.type != IF and self.curr_token.type != WHILE and self.curr_token.type != FOR and self.curr_token.type != FUNCTION:
+            b = self.parse()
+            self.check_type(SEMI)
+            self.check_type(END)
+            return While(c, b)
+        b = self.parse()
+        self.check_type(END)
+        return While(c, b)
+    
+    def parse_list_append(self):
+        self.check_type(APPEND)
+        self.check_type(LPAREN)
+        var = self.variable()
+        self.check_type(COMMA)
+        item = self.parse()
+        self.check_type(RPAREN)
+        return list_append(var, item)
+    
+
+    
+    def parse_list_slice(self, c):
+     
+        self.check_type(LSPAREN)
+        if self.curr_token.type==COMMA:
+            start = NumLiteral(0)
+        else:
+            start = self.parse()
+        
+        if self.curr_token.type==RSPAREN:
+            index_type = True
+            self.check_type(RSPAREN)
+
+        elif self.curr_token.type==COMMA:
+            index_type = False
+            self.check_type(COMMA)
+            end = self.parse()
+        else:
+            index_type = False
+            end = self.parse()
+        
+    
+        if index_type==False:
+            if self.curr_token.type==COMMA:
+                self.check_type(COMMA)
+                if self.curr_token.type!=RSPAREN:
+                    jump = self.parse()   
+                else:
+                    jump = NumLiteral(1)
+
+            else:
+                jump = NumLiteral(1)
+            self.check_type(RSPAREN)
+        else:
+            end = None
+            jump = None
+        return list_Slicing(c, start, end, jump)
+
+
+
+    def parse_inc(self):
+        self.check_type(INC)
+        self.check_type(LPAREN)
+        c = self.parse()
+        self.check_type(RPAREN)
+        return Increment(c)
+
+    def parse_dec(self):
+        self.check_type(DEC)
+        self.check_type(LPAREN)
+        c = self.parse()
+
+        self.check_type(RPAREN)
+        return Decrement(c)
+    
+    def parse_len(self):
+        
+        self.check_type(LPAREN)
+        c = self.parse()
+        self.check_type(RPAREN)
+        return length(c)
+    
+    def parse_head(self):
+        
+        self.check_type(LPAREN)
+        c = self.parse()
+        self.check_type(RPAREN)
+        return list_head(c)
+    
+    def parse_tail(self):
+        
+        self.check_type(LPAREN)
+        c = self.parse()
+        self.check_type(RPAREN)
+        return list_tail(c)
+    
+    def parse_isempty(self):
+        
+        self.check_type(LPAREN)
+        c = self.parse()
+        self.check_type(RPAREN)
+        return list_isempty(c)
+         
+    
+    def parse_slice(self, c):
+     
+        self.check_type(LSPAREN)
+        if self.curr_token.type==COMMA:
+            # self.check_type(COMMA)
+            start = NumLiteral(0)
+        else:
+            start = self.parse()
+        
+        if self.curr_token.type==RSPAREN:
+            index_type = True
+            self.check_type(RSPAREN)
+
+        elif self.curr_token.type==COMMA:
+            index_type = False
+            self.check_type(COMMA)
+            if self.curr_token.type!=COMMA:
+                end = self.parse()
+            else:
+                end = None
+        else:
+            index_type = False
+            end = self.parse()
+        
+    
+        if index_type==False:
+            if self.curr_token.type==COMMA:
+                self.check_type(COMMA)
+                if self.curr_token.type!=RSPAREN:
+                    jump = self.parse()   
+                else:
+                    jump = NumLiteral(1)
+
+            else:
+                jump = NumLiteral(1)
+            self.check_type(RSPAREN)
+        else:
+            end = None
+            jump = None
+        return Slicing(c, start, end, jump)
+    
+   
+    def parse_print(self):
+        self.check_type(PRINT)
+        self.check_type(LPAREN)
+        if self.curr_token.type != RPAREN:
+            e = self.logical()
+        else:
+            e = None
+        # print(e)
+        self.check_type(RPAREN)
+        # if self.curr_token.type != END:
+        #     e = self.logical()
+        # else:
+        #     e = None
+        # # print(e)
+        # self.check_type(END)
+        return Statement("print", e)
+        
+    def parse_return(self):
+        self.check_type(RETURN)
+        
+        e = self.logical()
+        return Statement("return", e)
+    
+    def parse_list(self, Type):
+        if Type != LSPAREN:
+            # print("ENTER")
+            self.check_type(COLON)
+            
+            token = self.curr_token
+            self.check_type(INTEGER)
+            Type = token.type
+            datatype = Type
+
+            # print(datatype)
+
+        else:
+            datatype = NONE
+
+
+        self.check_type(LSPAREN)
+        ele = self.parse()
+        value =[ele]
+        token = self.curr_token
+        Type = token.type
+
+        while Type!= RSPAREN:
+            self.check_type(COMMA)
+            ele = self.parse()
+            value.append(ele)
+            token = self.curr_token
+            # print(token)
+            Type = token.type
+        self.check_type(RSPAREN)
+        # print(type(datatype))
+
+        # print("done and dusted")
+
+        return Listing(value, datatype)
+            
+
+
+
+    def parse_func(self):
+        self.check_type(FUNCTION)
+        # name = self.variable("Variable")
+        name = self.variable()
+        self.check_type(LPAREN)
+        # var = self.variable("Variable")
+        var = self.variable()
+        token = self.curr_token
+        Type = token.type
+        params = [var] if var != None else []
+        
+        while Type != RPAREN:
+            self.check_type(COMMA)
+            if self.curr_token.type == RPAREN:
+                break
+            # var = self.variable("Variable")
+            var = self.variable()
+            
+            params.append(var)
+            token = self.curr_token
+            Type = token.type
+        
+        self.check_type(RPAREN)
+        if self.curr_token.type == BEGIN:
+            body = self.parse()
+        else:
+            self.check_type(BEGIN)
+        
+
+        
+        
+        return Function(name, params, body)
+
+    def parse_func_call(self, n):
+        node = n
+        self.check_type(LPAREN)
+        if self.curr_token.type == RPAREN:
+            self.check_type(RPAREN)
+            if self.curr_token.type == LPAREN:
+                return self.parse_func_call(FunCall(node, []))
+            return FunCall(node, [])
+        var = self.logical()
+        token = self.curr_token
+        Type = token.type
+        params = [var] if var != None else []
+        
+        while Type != RPAREN:
+            self.check_type(COMMA)
+            if self.curr_token.type == RPAREN:
+                break
+            var = self.logical()
+            
+            params.append(var)
+            token = self.curr_token
+            Type = token.type
+        
+        self.check_type(RPAREN)
+        if self.curr_token.type == LPAREN:
+            return self.parse_func_call(FunCall(node, params))
+
+        return FunCall(node, params)
+
+    def variable(self, ASTtype=None):
+        token = self.curr_token
+        Type = token.type
+        if Type == ID:
+            self.check_type(ID)
+            if ASTtype=="Variable":
+                token = self.curr_token
+                Type = token.type
+                #self.parse_slice(Variable(token.value), Type)
+                return Variable(token.value)
+                
+            else:
+                return MutVar(token.value)
+            
+        
+    
+    def precedence3(self):
+        '''precedence3 : INTEGER | LPAREN precedence1 RPAREN | BoolLiteral | Indentifier| (+/-)precedence3 | StringLiteral'''
+        token = self.curr_token
+        Type = token.type
+        if Type == PLUS:
+            self.check_type(PLUS)
+            node = UnOp(operator=token.value, mid=self.precedence3())
+            return node
+        elif Type == MINUS:
+            self.check_type(MINUS)
+            node = UnOp(operator=token.value, mid=self.precedence3())
+            return node
+        elif Type == LPAREN:
+            self.check_type(LPAREN)
+            # node = self.precedence1() 
+            node = self.logical()
+            self.check_type(RPAREN)
+            return node
+        elif Type == FRACTION_CONST:
+            self.check_type(FRACTION_CONST)
+            return NumLiteral(token.value)
+        elif Type == REAL_CONST:
+            self.check_type(REAL_CONST)
+            return FloatLiteral(token.value)
+        elif Type == INTEGER_CONST:
+            self.check_type(INTEGER_CONST)
+            return IntLiteral(token.value)        
+        elif Type == TRUE or Type == FALSE:
+            self.check_type(Type)
+            return BoolLiteral(token.value)
+        elif Type == LEN:
+            self.check_type(LEN)
+            return self.parse_len()
+        elif Type == HEAD:
+            self.check_type(HEAD)
+            return self.parse_head
+        elif Type == TAIL:
+            self.check_type(TAIL)
+            return self.parse_tail
+        elif Type == ISEMPTY:
+            self.check_type(ISEMPTY)
+            return self.parse_isempty
+        elif Type == LIST:
+            self.check_type(LIST)
+            if self.curr_token.type == COLON:
+                return self.parse_list(self.curr_token.type)
+            return self.parse_list(self.curr_token.type)
+        elif Type == ID:
+            self.check_type(ID)
+            if self.curr_token.type == LPAREN:
+                return self.parse_func_call(MutVar(token.value))
+            elif self.curr_token.type == LSPAREN:
+                return self.parse_slice(MutVar(token.value))
+            return (MutVar(token.value))
+        elif Type == STRING:    
+            # Nothing new here, just eat the STRING token and return the String() AST.
+            self.check_type(STRING)
+            return StringLiteral(token.value)
+        
+        else:
+            # if Type == END:
+            #     self.check_type(END)
+            #     return
+            print("None of the suggested tokens found:", INTEGER_CONST, ID, LPAREN, STRING, TRUE, FALSE, "...")
+            self.check_type(INTEGER_CONST)
+            
+    
+        
+
+    def exponential(self):
+        """exponential : precedence3 | precedence3 POWER precedence3"""
+        node = self.precedence3()
+        token = self.curr_token
+        Type = token.type
+        l = [node]
+        if Type == POWER:
+            while (Type == POWER):
+                token = self.curr_token
+                if token.type == POWER:
+                    self.check_type(POWER)
+                e = self.precedence3()
+                # print(e)
+                l.append(e)
+                Type = self.curr_token.type
+                # e = self.precedence3()
+            # print(l)
+            
+            i = 1
+            while len(l) > 0 :
+                e = l.pop()
+                if i==1:
+                    
+                    node = BinOp(left=l.pop(), operator=token.value, right=e)
+                else:
+                    node = BinOp(left=e, operator=token.value, right=node)
+                i+=1
+
+        return node
+        
+        
+    def precedence2(self):
+        """precedence2 : precedence3 | precedence3 MUL/DIV precedence3"""
+        node = self.exponential()
+        token = self.curr_token
+        Type = token.type
+        while (Type == MUL or  Type ==FLOAT_DIV  or Type == MODULO or Type == INT_DIV):
+            token = self.curr_token
+            if token.type == MUL:
+                self.check_type(MUL)
+            elif token.type == FLOAT_DIV:
+                self.check_type(FLOAT_DIV)
+            elif token.type == INT_DIV:
+                self.check_type(INT_DIV)                
+            elif token.type == MODULO:
+                self.check_type(MODULO)
+            elif token.type == INT_DIV:
+                self.check_type(INT_DIV)
+            node = BinOp(left=node, operator=token.value, right=self.exponential())
+            Type = self.curr_token.type
+        return node
+
+    def precedence1(self):
+        """precedence1 : precedence2 | precedence2 PLUS/MINUS precedence2"""
+        node = self.precedence2()
+        Type = self.curr_token.type
+        while (Type == PLUS or  Type ==MINUS):
+            token = self.curr_token
+            if token.type == PLUS:
+                self.check_type(PLUS)
+            elif token.type == MINUS:
+                self.check_type(MINUS)
+            node = BinOp(left=node, operator=token.value, right=self.precedence2())
+            Type = self.curr_token.type
+        return node
+
+    # def parse(self):
+    #     return self.precedence1()
+    def relational(self, n=None):
+        """relational : precedence1 | precedence1 relationalOperator precedence1"""
+        if n == None:
+            node = self.precedence1()
+        else:
+            node = n
+        Type = self.curr_token.type
+        # print(Type)
+        # while(Type == GT or Type == GTEQ or Type == LT or Type == LTEQ):
+        if(Type == GT or Type == GTEQ or Type == LT or Type == LTEQ or Type == EQEQ or Type == NOTEQ):
+            token = self.curr_token
+            if token.type == GT:
+                self.check_type(GT)
+            elif token.type == GTEQ:
+                self.check_type(GTEQ)
+            elif token.type == LT:
+                self.check_type(LT)
+            elif token.type == LTEQ:
+                self.check_type(LTEQ)
+            elif token.type == EQEQ:
+                self.check_type(EQEQ)
+            elif token.type == NOTEQ:
+                self.check_type(NOTEQ)
+            node = BinOp(left=node, operator=token.value, right=self.precedence1())
+        # Type = self.curr_token.type
+        return node
+    
+    def logical(self, n=None):
+        """logical : relational | relational logicalOperator relational"""
+        if n == None:
+            node = self.relational()
+        else:
+            node = n
+        # node = self.relational()
+        Type = self.curr_token.type
+        if(Type == OR or Type == AND):
+            token = self.curr_token
+            if token.type == AND:
+                self.check_type(AND)
+            elif token.type == OR:
+                self.check_type(OR)
+            node = BinOp(left=node, operator= token.value, right=self.relational())
+        return node
+    
+    def assignment(self, n=None):
+        """assignment : variable ASSIGN relational"""
+        if n == None:
+            node = self.variable()
+        else:
+            node = n
+        Type = self.curr_token.type
+        # token = self.curr_token
+        # print(Type)
+
+        
+        # if Type == ASSIGN:
+        #     self.check_type(ASSIGN)
+        #     token = self.curr_token
+        #     node = BinOp(left=node, operator=token.value, right=self.logical())
+        # else:
+        #     if isinstance(node,MutVar):
+        #         node = self.logical(Get(node))  
+        #     else:
+        #         node = self.logical()  
+        
+        if(Type == ASSIGN or Type == PLUSEQ or Type == MINUSEQ or Type == FLOAT_DIVEQ or Type == MULEQ or Type == POWEREQ):
+            token = self.curr_token
+            if Type == ASSIGN:
+                self.check_type(ASSIGN)
+                node = BinOp(left=node, operator= token.value, right=self.logical())
+            elif Type == MULEQ:
+                self.check_type(MULEQ)
+                # print(self.curr_token)
+                node = BinOp(left=node, operator= token.value, right=self.logical())
+            elif Type == MINUSEQ:
+                self.check_type(MINUSEQ)
+                # print(self.curr_token)
+                node = BinOp(left=node, operator= token.value, right=self.logical())
+            elif Type == FLOAT_DIVEQ:
+                self.check_type(FLOAT_DIVEQ)
+                # print(self.curr_token)
+                node = BinOp(left=node, operator= token.value, right=self.logical())
+            elif Type == PLUSEQ:
+                self.check_type(PLUSEQ)
+                # print(self.curr_token)
+                node = BinOp(left=node, operator= token.value, right=self.logical())
+            elif Type == POWEREQ:
+                self.check_type(POWEREQ)
+                # print(self.curr_token)
+                node = BinOp(left=node, operator= token.value, right=self.logical())
+        else:
+            if isinstance(node,MutVar):
+                node = self.logical(node)  
+            else:
+                node = self.logical()  
+
+        return node
+    
+
+    def parse(self):
+        """parse : parse_if | parse_print | parse_begin | assignment"""
+        match self.curr_token.type:
+            case 'IF':
+                return self.parse_if()
+            case 'WHILE':
+                return self.parse_while()
+            case 'FOR':
+                return self.parse_for()
+            case 'PRINT':
+                return self.parse_print()
+            case 'RETURN':
+                return self.parse_return()
+            case 'BEGIN':
+                return self.parse_begin()
+            case 'FUNCTION':
+                return self.parse_func()
+            case 'BREAK':
+                self.check_type(BREAK)
+                return Statement("break",NumLiteral(0))
+            case 'INC':
+                return self.parse_inc()
+            case 'DEC':
+                return self.parse_dec()
+            case 'APPEND':
+                return self.parse_list_append()
+            # case 'SEMI':
+            #     return
+                # return self.parse()
+            case _:
+                node = self.variable()
+                if self.curr_token.type == LPAREN:
+                    return self.parse_func_call(node)
+                
+                # node = MutVar(node.name)
+                return self.assignment(node)

String_op_testcases.txt

@@ -0,0 +1,16 @@
+{String Operations}
+
+BEGIN 
+str := "String Checking";
+PRINT str END;
+PRINT LEN(str) END;
+x := 2;
+y := 13;
+z := 3;
+PRINT str[x,y,z] END;
+PRINT str[14] END;
+PRINT str[1,5] END;
+PRINT str[,,] END;
+{PRINT "bisbciwi"[4] END;}
+
+END

app.py

@@ -0,0 +1,53 @@
+import streamlit as st
+import time
+import lexer as lex
+# import Parser as prs
+from io import StringIO
+from sim import *
+import time
+from streamlit.components.v1 import html
+
+# import sys
+
+st.write("""AZKABAN language""")
+
+
+file = st.file_uploader("Pick a file")
+
+if file is not None:
+    stringio = StringIO(file.getvalue().decode("utf-8"))
+    # st.write(stringio)
+    string_data = stringio.read()
+    # st.write(string_data)
+    text = st.text_area('Please Enter Your Code Here', string_data)
+else:
+    text = st.text_area('Please Enter Your Code Here', "PRINT(3+4);")
+# print(text)
+start = time.time()
+# text = "PRINT 3@(1/2) END"
+# text = "3 > 4"
+# text = "-2*(1---2)"
+# text = "PRINT 2-+ +3 END"
+# if len(text) != 0:
+text = "BEGIN "+text+" END"
+
+l = lex.Lexer(text)   
+p = prs.Parser(l)
+i = Interpreter(p)
+# print(eval(i))
+
+
+eval(i) 
+st.write("Output:")
+
+# html(open("eval.txt").read(), height=100, scrolling=True)
+
+st.write(open("eval.txt","r").readlines())
+
+st.write("Time taken", time.time()-start)
+print("Time taken", time.time()-start)
+
+
+
+
+

automat.py

@@ -0,0 +1,174 @@
+import os
+import lexer as lex
+from sim import *
+import sys
+import re
+import platform
+
+def run_test_cases(dir_path):
+    while True:
+        sys.stdout = sys.__stdout__
+        command = input("Enter command : ")
+        match command:
+            case "all":
+                dir = giveFilesWithFolders(dir_path)
+                # for file in os.listdir(dir_path):
+                for file in dir:
+                    if file.endswith(".txt"):
+
+                        # print("Running test case: " + file)
+                        # with open(os.path.join(dir_path, file)) as f:
+                        with open(file) as f:
+                            text = f.read()
+                        text = "BEGIN "+text+" END"
+                        l = lex.Lexer(text)   
+                        p = prs.Parser(l)
+                        i = Interpreter(p)
+                        eval(i)
+                        sys.stdout = sys.__stdout__
+
+
+                        # with open('tempt2.txt', 'r') as f:
+                        #     print(f.read())
+
+                        # print('------------------------')
+
+                        # with open(os.path.join(dir_path, 'tempt.txt')) as f:
+                        #     print(f.read())
+                        # if platform.platform().startswith('Windows'):
+                        #     output = os.popen('fc eval.txt solution.txt').read()
+                        # else:
+                        #     output = os.popen('diff eval.txt solution.txt').read()
+                        # print(output, len(output))
+
+                        # print(output)
+                        # if output == "":
+                        # compare two text files
+
+                        if open('eval.txt').read() == open('solution.txt').read():
+                            print("Test passed: " + file)
+                        else:
+                            print("Test failed: " + file)
+                        # output = os.popen('').read()
+                        # for line in lines[1:]:
+                        #     print(line)
+                # continue
+
+            case "exit":
+                break
+            case default:
+                try:
+                    dir = giveFilesWithFolders(dir_path)
+                    # with open(os.path.join(dir_path, default)) as f:
+                    flag = 1
+                    # if re.search(".", default) != None:
+                    if default.find(".")>=0:
+                        # print("e111")
+                        
+                        for file in dir:
+                            if file.endswith(default):
+                                flag = 0
+                                with open(file) as f:
+                                    text = f.read()
+                                text = "BEGIN "+text+" END"
+                                l = lex.Lexer(text)
+                                p = prs.Parser(l)
+                                i = Interpreter(p)
+                                eval(i)
+                                sys.stdout = sys.__stdout__
+
+                                # if platform.platform().startswith('Windows'):
+                                #     output = os.popen('fc eval.txt solution.txt').read()
+                                # else:
+                                #     output = os.popen('diff eval.txt solution.txt').read()
+
+                               
+                                # print(output)
+                                # if output == "":
+                                if open('eval.txt').read() == open('solution.txt').read():
+                                    print("Test passed: " + file)
+                                else:
+                                    print("Test failed: " + file)
+                        if flag == 1:
+                            print("File or Folder not found")
+
+                    else:
+                        # print("f222")
+                        # run all files in folder
+                        for file in dir:
+                            # print(default)
+
+                            if file.startswith(default) or (file.find(default+"\\")>=0):
+                                # print("entering")
+                                flag = 0
+                                with open(file) as f:
+                                    text = f.read()
+
+                                text = "BEGIN "+text+" END"
+                                l = lex.Lexer(text)   
+                                p = prs.Parser(l)
+                                i = Interpreter(p)
+                                eval(i)
+                                sys.stdout = sys.__stdout__
+                                # if platform.platform().startswith('Windows'):
+                                #     output = os.popen('fc eval.txt solution.txt').read()
+                                # else:
+                                #     output = os.popen('diff eval.txt solution.txt').read()
+
+
+                                # print(output)
+                                # if output == "":
+                                if open('eval.txt').read() == open('solution.txt').read():
+                                    print("Test passed: " + file)
+                                else:
+                                    print("Test failed: " + file)
+                        if flag == 1:
+                            print("File or Folder not found")
+
+                except:
+                    print("File or Folder not found")
+                    # if f == None:
+                    #     print("File not found")
+                    #     continue
+
+def giveFilesWithFolders(dir_path):
+    files = []
+    for file in os.listdir(dir_path):
+        if os.path.isdir(os.path.join(dir_path, file)):
+            
+            # files.append(file)
+            files.extend(giveFilesWithFolders(os.path.join(dir_path, file)))
+        else:
+            files.append(dir_path+"\\"+file)
+    return files
+ 
+
+if __name__ == "__main__":
+    # start = time.time()
+    # run_test_cases("test_cases")
+    dir = os.listdir("test_cases")
+    dir.append("")
+    print(dir)
+    dir = giveFilesWithFolders("test_cases")
+    print(dir)
+    # default = input("Enter folder")
+    # for i in dir:
+    #     x = re.search(".", i)
+        
+    #     print(i.startswith(default) or (i.find(default+"\\")>=0))
+
+    run_test_cases("test_cases")
+        # print("hi")
+        # print(x)
+        # if not x:
+            # print("hi")
+            # run_test_cases("test_cases/" + i)
+    # print("Time taken", time.time()-start)
+
+
+# import platform
+
+# print(platform.platform())
+
+
+# code to write in file

dataclasses_sim.py

@@ -0,0 +1,273 @@
+from dataclasses import dataclass
+from fractions import Fraction
+from typing import Union, Mapping, Optional, NewType, List
+
+# Resolver On/Off
+resolverOn = True #False ; Turn to False if not using resolver
+currentID = 0
+
+def fresh():
+    global currentID
+    currentID = currentID + 1
+    return currentID
+@dataclass
+class BoolLiteral:
+    value: bool
+    def __init__(self, *args):
+        self.value = bool(*args)
+    # type: SimType = BoolType()
+
+@dataclass
+class NumLiteral:
+    value: Fraction
+    # type: SimType = NumType()
+    def __init__(self, *args):
+        self.value = Fraction(*args)
+
+@dataclass
+class IntLiteral:
+    value: Fraction
+    # type: SimType = NumType()
+    def __init__(self, *args):
+        self.value = int(*args)
+        
+
+@dataclass
+class FloatLiteral:
+    value: Fraction
+    # type: SimType = NumType()
+    def __init__(self, *args):
+        self.value = float(*args)
+
+@dataclass
+class StringLiteral:
+    value : str
+    def __init__(self, *args):
+        self.value = str(*args)
+
+@dataclass
+class BinOp:
+    operator: str
+    left: 'AST'
+    right: 'AST'
+    def get_left(self):
+        return self.left
+    def get_right(self):
+        return self.right
+
+
+@dataclass
+class UnOp:
+    operator: str
+    mid: 'AST'
+    def get_mid(self):
+        return self.mid
+
+@dataclass
+class Variable:
+    name: str
+
+@dataclass
+class Let:
+    var: 'AST'
+    e1: 'AST'
+    e2: 'AST'
+
+@dataclass
+class LetMut:
+    var: 'AST'
+    e1: 'AST'
+    e2: 'AST'
+
+@dataclass
+class Put:
+    var: 'AST'
+    e1: 'AST'
+
+@dataclass
+class Get:
+    var: 'AST'
+
+@dataclass
+class LetFun:
+    name: 'AST'
+    params: List['AST']
+    body: 'AST'
+    expr: 'AST'
+
+@dataclass
+class FunCall:
+    fn: 'AST'
+    args: List['AST']
+
+
+@dataclass
+class Statement:
+    command: str
+    statement : "AST"
+
+@dataclass
+class IfElse:
+    condition: 'AST'
+    then_body: 'AST'
+    else_body: 'AST' 
+
+@dataclass
+class Seq:
+    statements: List['AST']
+
+@dataclass
+class MutVar:
+    name: str
+    value: 'AST'
+    id: int #Final[int]  #comment it if not using resolver
+    def __init__(self, name) -> None:
+        self.value = None
+        self.name = name
+        self.id = fresh() if resolverOn else 0
+    def get(self):
+        return self.value
+    def put(self, val):
+        self.value = val
+
+@dataclass
+class ForLoop:
+    start : 'AST'
+    end : 'AST'
+    increment : 'AST'
+    body : 'AST'
+    
+@dataclass
+class While:
+    condition: 'AST'
+    body: 'AST'
+
+@dataclass
+class Function:
+    name: 'AST'
+    params: List['AST']
+    body: 'AST'
+    
+
+@dataclass
+class CallStack:
+    clstk: List
+
+@dataclass
+class Increment:
+    var_literal : 'AST'
+
+@dataclass
+class Decrement:
+    var_literal : 'AST'
+
+
+@dataclass
+class Slicing:
+    name : 'AST'
+    start : 'AST'
+    end : 'AST'
+    jump : 'AST'
+
+@dataclass
+class list_Slicing:
+    name : 'AST'
+    start : 'AST'
+    end : 'AST'
+    jump : 'AST'
+
+
+@dataclass
+class Listing:
+    value : List['AST']
+    datatype : 'AST'
+
+@dataclass
+class list_append:
+    var : 'AST'
+    item : 'AST'
+        
+        
+@dataclass
+class list_head:
+    name: 'AST'
+
+
+@dataclass
+class list_tail:
+    name: 'AST'
+
+@dataclass
+class list_isempty:
+    name: 'AST'
+
+
+@dataclass
+class length:
+    name: 'AST'   
+
+class Environment:
+    envs: List
+
+    def __init__(self):
+        self.envs = [{}]
+
+    def enter_scope(self):
+        self.envs.append({})
+
+    def exit_scope(self):
+        assert self.envs
+        self.envs.pop()
+
+    def add(self, name, value):
+        assert name not in self.envs[-1]
+        self.envs[-1][name] = value
+
+    def get(self, name):
+        for env in reversed(self.envs):
+            if name in env:
+                return env[name]
+        print("Current Environment", self.envs)
+        print("Current AST", self.program)
+        raise KeyError()
+
+    def update(self, name, value):
+        for env in reversed(self.envs):
+            if name in env:
+                env[name] = value
+                return
+        print("Current AST", self.program)
+        print("Current Environment", self.envs)
+        raise KeyError()
+    
+    def check(self, name):
+        for env in reversed(self.envs):
+
+            if name in env:
+                return True
+        else:
+            return False
+        # raise KeyError()
+    def addWithOther(self, n1, n2, v2):
+        for env in reversed(self.envs):
+            if n1 in env:
+                env[n2] = v2
+
+AST = NumLiteral | BinOp | Variable | Let | BoolLiteral | UnOp | StringLiteral | IfElse | MutVar | While | Seq | Function | LetFun | FunCall | Slicing
+
+@dataclass
+class FnObject:
+    params: List['AST']
+    body: 'AST'
+    def get(self):
+        return self#FnObject(self.params, self.body)
+Value = Fraction
+Val = bool
+
+
+
+# Val_string = string
+
+@dataclass
+class InvalidProgram(Exception):
+    pass

error_in_sim

@@ -0,0 +1,4 @@
+Current AST
+None
+Current Environment:
+[{}, {'i': MutVar(name='i', value=Fraction(10, 1), id=47)}]

eval.txt

@@ -0,0 +1 @@
+7

fizz_buzz.txt

@@ -0,0 +1,46 @@
+{FIZZZ BUZZ code}
+
+BEGIN 
+   
+   n:=35;
+   i:=1;
+
+   WHILE i<=n
+   DO
+      BEGIN
+         IF i%3=0 && i%5=0
+         THEN 
+            BEGIN
+               PRINT "FIZZ BUZZ" END;
+            END
+         ELSE
+         END;
+          IF i%3=0 && i%5<>0
+         THEN 
+            BEGIN
+               PRINT "FIZZ" END;
+            END
+         ELSE
+         END;
+         IF i%3<>0 && i%5=0
+         THEN 
+            BEGIN
+               PRINT "BUZZ" END;
+            END
+         ELSE
+         END;
+         IF i%3<>0 && i%5<>0
+         THEN 
+            BEGIN
+               PRINT i END;
+            END
+         ELSE
+         END;
+         
+         i:=i+1;
+    
+      END
+   END;
+END
+
+  

for_loop_testing_cases.txt

@@ -0,0 +1,55 @@
+{case 1}
+{BEGIN 
+    p:=1;
+    q:=1;
+    FOR i:= 1 ; i < 126 ; i := i + 1 
+    DO 
+        BEGIN 
+        q:=q*p;
+        p:=p+1;   
+        {PRINT p END;}          
+        PRINT q END;
+        PRINT i END;
+        END 
+    END; 
+END
+}
+
+{case 2}
+{BEGIN 
+    p:=1;
+    q:=1;
+    FOR i:= 125 ; i > 0 ; i := i - 1 
+    DO 
+        BEGIN 
+        q:=q*p;
+        p:=p+1;   
+        {PRINT p END;}          
+        PRINT q END;
+        PRINT i END;
+        END 
+    END; 
+END}
+
+{case 3}
+BEGIN 
+    p:=1;
+    q:=1;
+    FOR i:= 10 ;  ; i := i - 1 
+    DO 
+        BEGIN 
+        q:=q*p;
+        p:=p+1;   
+        {PRINT p END;}          
+        PRINT q END;
+        PRINT i END;
+        IF i <= 0 
+            THEN
+                BEGIN 
+                BREAK;
+                END
+            ELSE
+                END   
+        END 
+    END; 
+END

input.txt

@@ -0,0 +1,779 @@
+{Factorial of n}{
+BEGIN 
+    i:=1;
+    p:=1;
+    n:=1559; {when while used python ifelse, max limit=494 }
+    WHILE i<n
+    DO
+        BEGIN
+        p:=p*i;
+        i:=i+1;{
+        PRINT i END;
+        PRINT p END;}
+        END
+    END;
+
+    PRINT i END;
+    PRINT p END;
+END}
+{Fibonacci upto n numbers}{
+BEGIN
+    n:=20577; {when while used python ifelse, max limit=495; 10000 time taken 29.94s, 15000->60.9s, 20577(max limit)->118.23s print takes time }
+    f:=0;
+    s:=1;
+    PRINT f END;
+    PRINT s END;
+    i:=2;
+    WHILE i<n
+    DO
+        BEGIN
+        t:=s;
+        s:=s+f;
+        f:=t;
+        PRINT s END;
+        PRINT i END;
+        i:=i+1;
+        END
+    END;
+END}
+{Function Testing}{
+BEGIN
+    PRINT 2+3 END;
+    FUNCTION add(a,b)
+    BEGIN
+        c:=a+b;
+        RETURN c;
+    END;
+    PRINT add(2,5) END;
+END}
+{Recursive Function Testing (Factorial)}{
+BEGIN   
+    FUNCTION fact(n)
+    BEGIN
+        IF n<=1 
+        THEN RETURN 1
+        ELSE RETURN n*fact(n-1)
+        END;
+    END;
+    PRINT fact(98) END;
+END}
+{Recursive Fibonacci}{
+BEGIN
+    f:=0;
+    s:=1;
+    FUNCTION fibo(n)
+    BEGIN
+        IF n<=1
+        THEN RETURN f
+        ELSE 
+            BEGIN
+            t:=s;
+            s:=s+f;
+            f:=t;
+            fibo(n-1);
+            END
+        END;
+        
+    END;
+    PRINT fibo(123) END;
+END}
+{Project Euler Problem 1	Multiples of 3 or 5}{
+BEGIN
+    sum:=0;
+    n:=1000; {233168}
+    i:=1;
+    WHILE i<n
+    DO
+        BEGIN
+            IF i%3=0 || i%5=0
+            THEN 
+                BEGIN
+                    sum:=sum+i;
+                    PRINT i END;
+                END
+            ELSE 
+            END;
+            i:=i+1;
+        END
+    END;
+    PRINT "SUM=" END;
+    PRINT sum END;
+
+END}
+{Project Euler Problem 2	Even Fibonacci numbers}{
+BEGIN
+    sum:=0;
+    n:=4000000; {4613732}
+    f:=1;
+    s:=2;
+    WHILE f<=n
+    DO
+        BEGIN
+            t:=s;
+            s:=s+f;
+            f:=t;
+            IF f%2=0
+            THEN 
+                BEGIN
+                sum+=f;
+                PRINT f END;
+                END
+            ELSE
+            END;
+        END
+    END;
+    PRINT "SUM=" END;
+    PRINT sum END;
+END}
+{Project Euler Problem 3	Largest prime factor}{
+BEGIN
+    n:=600851475143; {13195->5,7,13,29->0.38s, after optimize/actual better soln->0.014s; 600851475143->71,839,1471,6857->0.23s}
+    i:=2;
+    maxPrimeFactor:=0;
+    FUNCTION findFirstPrimeFactor(num, ini)
+    BEGIN 
+        j:=ini;
+        flag:=0;
+        WHILE j<=num/2
+        DO
+            BEGIN
+                IF num%j=0
+                THEN 
+                    BEGIN
+                        flag:=1;
+                        {i:=j;
+                        PRINT j END;}
+                        BREAK;
+                    END
+                ELSE END;
+                j+=1;
+            END
+        END;
+        
+        IF flag=0
+        THEN RETURN num
+        ELSE RETURN j
+        END;
+    END;
+
+    {IF isPrime(n)=FALSE
+    THEN 
+        BEGIN}
+            WHILE i<n
+            DO
+                BEGIN
+                    i:=findFirstPrimeFactor(n, i);
+                    {IF isPrime(i)
+                    THEN 
+                        BEGIN}
+                            prevN:=n;
+                            WHILE n%i=0
+                            DO 
+                                BEGIN
+                                    
+                                    n:=n/i;
+                                    
+                                END
+                            END;
+                            IF prevN<>n
+                            THEN 
+                                BEGIN
+                                maxPrimeFactor:=i;
+                                PRINT i END; 
+                                END
+                            ELSE END;
+                            
+                            
+                       { END
+                    ELSE END;
+                    i+=1;}
+                END
+            END;
+            
+        {END
+    ELSE
+        
+        
+        
+    END;}
+    {maxPrimeFactor:=n;}
+    PRINT "Max Prime Factor of n:" END;
+    PRINT maxPrimeFactor END;
+END}
+{Project Euler Problem 4	Largest palindrome product}{
+{7 second execution time}
+BEGIN
+    FUNCTION isPalin(num)
+    BEGIN
+        
+        pnum:=num;
+        sum:=0;
+        WHILE pnum>0
+        DO
+            BEGIN
+            sum := sum*10+pnum%10;
+            pnum:=pnum//10;
+            END
+        END;
+        RETURN sum=num;
+
+    END;
+
+    i:=999;
+    max:=0;
+    first:=0;second:=0;
+    WHILE i>=900
+    DO  
+        BEGIN
+            j:=i;
+            WHILE j>=900
+            DO
+                BEGIN
+                    IF isPalin(i*j) && max<i*j
+                    THEN 
+                        BEGIN
+                            max:=i*j;
+                            first:=i;
+                            second:=j;
+                            {PRINT max END;}
+                        END
+                    ELSE END;
+                    j:=j-1;
+                END
+            END;
+            i:=i-1;
+        END
+    END;
+    PRINT "Max Palindrome:" END;
+    PRINT max END;
+    PRINT "Constituent Numbers:" END;
+    PRINT first END; 
+    PRINT second END;   
+END}
+{Project Euler Problem 5	Smallest multiple}{
+BEGIN
+    FUNCTION HCF(first,second)
+    BEGIN
+        IF first<second {first should be kept bigger}
+        THEN 
+            BEGIN
+            t:=second;
+            second:=first;
+            first:=t;
+            END
+        ELSE END;
+        WHILE first%second<>0
+        DO
+            BEGIN
+            t:=second;
+            second:=first%second;
+            first:=t;
+            END
+        END;
+        RETURN second;
+        
+    END;
+    FUNCTION LCM(f,s)
+    BEGIN
+        RETURN f*s/HCF(f,s);
+    END;
+    i:=2;
+    n:=20; {10->2520; 20->232792560}
+    lcm:=i;
+    WHILE i<n
+    DO
+        BEGIN
+        i+=1;
+        lcm:=LCM(lcm, i);
+        END
+    END;
+    PRINT "Required Smallest Product:" END;
+    PRINT lcm END;
+
+END}
+{Project Euler Problem 6	Sum square difference}{
+BEGIN
+    n:=100; {10->2640; 100->25164150}
+    squareOfSum:=n*(n+1)*n*(n+1)/4;
+    sumOfSquare:=n*(n+1)*(2*n+1)/6;
+    PRINT "Resultant Difference" END;
+    PRINT squareOfSum-sumOfSquare END;
+END}
+{Project Euler Problem 9	Special Pythagorean triplet}{
+BEGIN
+    a:=1;b:=0;c:=0;
+    WHILE a<1000
+    DO 
+        BEGIN
+            IF a*a%(1000-a)=0
+            THEN 
+                BEGIN
+                b:=((1000-a)-a*a/(1000-a))/2;
+                c:=((1000-a)+a*a/(1000-a))/2;
+                BREAK;
+                END
+            ELSE END;
+            a+=1;
+        END
+    END;
+    PRINT "a,b,c are:" END; {200, 375, 425}
+    PRINT a END;
+    PRINT b END;
+    PRINT c END;
+END}
+{Function Testing: Define function within another function, return, use it; almost first class}{
+BEGIN
+    FUNCTION f2(n)
+    BEGIN
+        RETURN n*n;
+    END;
+    FUNCTION f4(n)
+    BEGIN
+        RETURN n@n;
+    END;
+    FUNCTION f1(f3)
+    BEGIN
+        FUNCTION f11(n)
+        BEGIN
+            RETURN f3(n)*(n-1);
+            {PRINT "f11" END;}
+        END;
+        {PRINT "f1" END;}
+        RETURN f11;
+    END;
+    rf11:=f1(f2);
+    rf12:=f1(f4);
+    rf13:=f2(4);
+    rf14:=6;
+    PRINT rf14 END; {6}
+    PRINT rf13 END; {16}
+    PRINT rf11(5) END; {100}
+    PRINT rf12(3) END; {54}
+    {PRINT f3(3) END; {error}}
+
+END}
+{First Class Function Test 2}{
+BEGIN
+    FUNCTION f4(n)
+    BEGIN
+        RETURN n@n;
+    END;
+    FUNCTION f1(f3)
+    BEGIN
+        FUNCTION f11(n)
+        BEGIN
+            RETURN f3(n)*(n-1);
+            {PRINT "f11" END;}
+        END;
+        {PRINT "f1" END;}
+        RETURN f11;
+    END;
+    
+    rf12:=f1(f4);
+    PRINT rf12(3) END; {54}
+    PRINT f1(f4)(3) END; {54}
+    
+END}
+{First Class Function Test 3}{
+{BEGIN}
+    FUNCTION f2(n)
+    BEGIN
+        RETURN n*n;
+    END{;}
+    FUNCTION f4(n)
+    BEGIN
+        RETURN n@n;
+    END{;}
+    FUNCTION f5()BEGIN
+
+        FUNCTION f1(f3)
+        BEGIN
+            FUNCTION f11(n)
+            BEGIN
+                RETURN f3(n)*(n-1);
+                {PRINT "f11" END;}
+            END{;}
+            {PRINT "f1" END;}
+            RETURN f11;
+        END{;}
+        RETURN f1;
+    END{;}
+    rf5:=f5();
+    rf51:=rf5(f2);
+    PRINT( rf51(5)) {END}; {100}
+    rf11:=f5()(f4);
+    rf22:=f5();
+    PRINT( rf11(4)) {END}; {768}
+    PRINT (rf22(f4)(3)) {END}; {54}
+    PRINT (f5()(f2)(5)) {END}; {100}
+    
+{END}}
+{Resolver test; inspired from sir's class }{
+BEGIN
+    FUNCTION foo(a)
+    BEGIN
+        IF FALSE
+        THEN RETURN foo(a) {infinite loop}
+        ELSE RETURN a-2
+        END;
+    END;
+    g:=foo;
+    FUNCTION foo(a)
+    BEGIN
+        RETURN a+5;
+    END;
+    h:=foo;
+    PRINT g(0) END;
+    PRINT h(1) END;
+
+END}
+{resolver test 2}{
+BEGIN 
+    i:=1;
+    s:=i; {1}
+    a:=2;
+    i:=a; {2}
+    s:=a@i@a; {16}
+    n:=s;   {16}
+    IF i< n 
+    THEN BEGIN
+            b:=n;
+            PRINT n END;
+            WHILE i+b-25 < 10
+            DO
+                BEGIN
+                    n:=i*b/a-n%i;
+                    PRINT n END;
+                    i+=i;
+                END
+            END;
+        END
+    ELSE 
+            {n:=a;}
+            PRINT n END
+        
+    END;
+    PRINT i END;
+    PRINT a END;
+    PRINT s END;
+END}
+{Mutual Recursion Testing}{
+BEGIN
+    FUNCTION even(n)
+    BEGIN
+        IF n = 0
+        THEN RETURN TRUE
+        ELSE END;
+        IF n = 1
+        THEN RETURN FALSE
+        ELSE END;
+        RETURN odd(n-1);
+    END;
+    FUNCTION odd(m)
+    BEGIN
+        IF m = 0
+        THEN RETURN FALSE
+        ELSE END;
+        IF m = 1
+        THEN RETURN TRUE
+        ELSE END;
+        RETURN even(m-1);
+    END;
+    PRINT even(5) END;
+    PRINT odd(4) END;
+END}
+{Mutual Recursion Testing 2}{
+
+    FUNCTION even(n)
+    BEGIN
+        IF n = 0
+        THEN RETURN TRUE;
+        ELSE END
+        IF n = 1
+        THEN RETURN FALSE;
+        ELSE END
+        RETURN odd(n-1);
+    END
+    FUNCTION odd(m)
+    BEGIN
+        PRINT ("1st Odd") ;
+        IF m = 0
+        THEN RETURN FALSE;
+        ELSE END
+        IF m = 1
+        THEN RETURN TRUE;
+        ELSE END
+        RETURN even(m-1);
+    END
+    PRINT (even(42)) ;
+    PRINT (odd(157)) ;
+    FUNCTION odd(m)
+    BEGIN
+        PRINT ("2nd Odd") ;
+        IF m = 0
+        THEN RETURN FALSE;
+        ELSE END
+        IF m = 1
+        THEN RETURN TRUE;
+        ELSE END
+        RETURN even(m-1);
+    END
+    PRINT (even(5)) ;
+    PRINT (odd(4)) ;
+}
+{Function binding Testing}{
+BEGIN
+    FUNCTION add(a,b)
+    BEGIN
+        c:=a+b;
+        RETURN dummy(c);
+    END;
+    FUNCTION dummy(a)
+    BEGIN
+        RETURN a;
+    END;
+    PRINT add(7,5) END;
+END}
+{print test}{
+BEGIN 
+    a:=1;
+    PRINT a END;
+END}
+
+{multiple ifelse testing}{
+BEGIN
+    n:=0;
+    a:=0;
+    IF n = 0
+        THEN a:=1
+        ELSE END;
+    IF n = 1
+        THEN a:=0
+        ELSE END; 
+    IF n = 2
+        THEN a:=2
+        ELSE END;    
+    PRINT a END;
+END}
+
+{multiple ifelse to test return working}{
+BEGIN
+    FUNCTION add(n)
+        BEGIN
+        IF n = 0
+            THEN RETURN 1
+            ELSE END;
+        IF n = 1
+            THEN RETURN 0
+            ELSE END;
+        IF n = 2
+            THEN RETURN 2
+            ELSE END;      
+        END;
+    PRINT add(0) END;
+END}
+
+{case 3}{
+BEGIN 
+    p:=1;
+    q:=1;
+    FOR i:= 10 ;  ; i := i - 1 
+    DO 
+        BEGIN 
+        q:=q*p;
+        p:=p+1;   
+        {PRINT p END;}          
+        PRINT q END;
+        PRINT i END;
+        IF i <= 0 
+            THEN
+                BEGIN 
+                BREAK;
+                END
+            ELSE
+                END   
+        END 
+    END; 
+END}
+{Project Euler Problem 12	Highly divisible triangular number}{
+BEGIN
+    
+    n:=500;  {5->28,6, time: 0.018s  ; 500->}
+    sum:=0;
+    max:=sum;
+    i:=1;
+    num:=1;
+    WHILE sum<=n
+    DO
+        BEGIN
+            sum:=1;
+            num:=i*(i+1)/2;
+            j:=1;
+            WHILE {j<num@(1/2)} j<=num/2
+            DO
+                BEGIN
+                    IF num%j = 0
+                    THEN 
+                        BEGIN
+                        sum+=1;
+                        END
+                    ELSE END;
+                    j+=1;
+                END
+            END;
+            
+            {IF num = num@(1/2) * num@(1/2)
+            THEN 
+                BEGIN
+                sum+=1;
+                END
+            ELSE END;}
+
+            IF max<sum
+            THEN 
+                BEGIN
+                    max:=sum;
+                    PRINT i END;
+                    PRINT sum END;
+                END
+            ELSE END;
+            i+=1; 
+            
+        END
+    END;
+    PRINT "Required Number:" END;
+    PRINT num END;
+    PRINT "No of factors of above number:" END;
+    PRINT sum END;
+    PRINT "No of factors to be exceeded:" END;
+    PRINT n END;
+END}
+{Token/Parser Test for not accepting ** and other such operators/tokens}{
+BEGIN
+    a:=1;
+    b:=2;
+    c:=b**03;
+    PRINT c END;
+END}
+{Project Euler Problem 30	Digit fifth powers}{
+BEGIN
+    sum := 0;
+    FOR i := 0; i <= 7*9*9*9*9*9*9; i := i + 1
+    DO
+    BEGIN
+        newsum := 0;
+        reduce := i;
+        WHILE reduce > 0
+        DO
+        BEGIN
+            digit := reduce % 10;
+            reduce := reduce // 10;
+            power := 1;
+            FOR j := 1; j <= 5; j+=1
+            DO
+                BEGIN
+                power := power * digit;
+                END
+            END;
+            newsum := newsum + power;
+        END
+        END;
+        IF newsum = i
+        THEN sum := sum + i
+        ELSE END;
+        END
+    END;
+    PRINT sum END;
+END}
+
+
+{test1}{
+BEGIN
+    a:=0;
+    BEGIN
+        a:=1;
+        PRINT a END;
+    END;
+    PRINT a END;
+END}
+{output: 1,1}
+
+{test2}{
+BEGIN
+    FUNCTION foo()
+        BEGIN
+            PRINT a END;
+        END;
+    a:=1;
+    PRINT foo() END;
+END}
+{output: 1}
+{Looks matter}{
+a:=1;
+PRINT("1st");
+PRINT (a) ;
+
+IF a = 1
+    THEN
+        BEGIN
+        PRINT("2nd");
+        PRINT (a) ;
+        END
+    ELSE
+        END
+WHILE a < 10
+    DO
+        BEGIN
+        
+        a:=a+1;
+        
+        END
+        
+    END
+PRINT("3rd");
+PRINT( a);
+FUNCTION foo()
+    BEGIN
+    PRINT (a) ;
+    END
+PRINT("4th");
+{PRINT (foo()) ;}
+foo();
+BEGIN
+    a:=4;
+    PRINT("5th");
+    PRINT (a) ;
+    
+END}
+{Looks matter 2}{
+
+    a:=1;
+    PRINT("1st");
+    PRINT (a) ;
+    IF a = 1
+    THEN
+        BEGIN
+        PRINT("2nd");
+        PRINT (a) ;
+        END
+    ELSE IF a = 2
+    THEN
+    PRINT("2.5nd");
+    ELSE
+    PRINT("2.75nd");
+    
+    END
+    WHILE a < 10
+        DO
+            a:=a+1;
+        END
+    PRINT("3rd");
+    PRINT( a);
+    c:=1;
+    b:=c+1;
+    PRINT(b);
+    b:=b+1;
+    PRINT(b);
+}
+
+

int_array_test.txt

@@ -0,0 +1,28 @@
+{BEGIN
+ 
+    x:= " BHAVINI";
+    T := LIST:INTEGER[~1,~3,~4, ~2, ~7];
+    PRINT T END;
+
+    APPEND(T, ~8);
+
+    PRINT LEN(T) END;
+
+    y := T[0];
+
+    PRINT T END;
+    PRINT y END;
+
+END}
+x:= " BHAVINI";
+T := LIST:INTEGER[~1,~3,~4, ~2, ~7];
+PRINT (T );
+
+APPEND(T, ~8);
+
+PRINT( LEN(T)) ;
+
+y := T[0];
+
+PRINT (T );
+PRINT (y );

lexer.py

@@ -0,0 +1,427 @@
+from dataclasses import dataclass
+import sys
+
+# punctuators
+EOF           = 'EOF'
+ID            = 'ID'
+FRACTION_CONST= 'FRACTION_CONST'
+INTEGER_CONST = 'INTEGER_CONST'
+REAL_CONST    = 'REAL_CONST'
+LPAREN        = 'LPAREN'
+RPAREN        = 'RPAREN'
+SEMI          = 'SEMI'
+DOT           = 'DOT'
+COLON         = 'COLON'
+COMMA         = 'COMMA'
+LSPAREN       = "LSPAREN"
+RSPAREN       = "RSPAREN"
+
+# operators
+ASSIGN        = 'ASSIGN'
+PLUS          = 'PLUS'
+MINUS         = 'MINUS'
+MUL           = 'MUL'
+FLOAT_DIV     = 'FLOAT_DIV'
+INT_DIV       = 'INT_DIV'
+EQEQ          = 'EQEQ'
+NOTEQ         = 'NOTEQ'
+GT            = 'GT'
+LT            = 'LT'
+GTEQ          = 'GTEQ'
+LTEQ          = 'LTEQ'
+MODULO        = 'MODULO'
+AND           = "AND"
+OR            = "OR"
+PLUSEQ        = 'PLUSEQ'
+MINUSEQ       = 'MINUSEQ'
+POWEREQ       = 'POWEREQ'
+MULEQ         = 'MULEQ'
+FLOAT_DIVEQ   = "FLOAT_DIVEQ"
+POWER         = 'POWER'
+
+# keywords
+PROGRAM       = 'PROGRAM'
+VAR           = 'VAR'
+INTEGER       = 'INTEGER'
+REAL          = 'REAL'
+INTEGER_DIV   = 'INTEGER_DIV'
+NONE          = 'NONE'
+READ          = 'READ'
+WRITE         = 'WRITE'
+BEGIN         = 'BEGIN'
+END           = 'END'
+IF            = 'IF'
+THEN          = 'THEN'
+ELSE          = 'ELSE'
+WHILE         = 'WHILE'
+DO            = 'DO'
+PRINT         = 'PRINT'
+STRING        = 'STRING'
+FUNCTION      = 'FUNCTION'
+RETURN        = 'RETURN'
+FOR           = 'FOR'
+RANGE         = "RANGE"
+BY            = "BY"
+TO            = "TO"
+BREAK         = "BREAK"
+INC           = "INC"
+DEC           = "DEC"
+LEN           = "LEN"
+LIST          = "LIST"
+APPEND        = "APPEND"
+POP           = "POP"
+HEAD          = "HEAD"
+TAIL          = "TAIL"
+ISEMPTY       = "ISEMPTY"
+
+
+# literals
+TRUE          = "TRUE"
+FALSE         = "FALSE"
+
+@dataclass
+# class to store the token types and values
+class Token:
+    type: str
+    value: object
+    
+    def __str__(self):
+        return 'Token({type}, {value})'.format(
+            type=self.type,
+            value=repr(self.value)
+        )
+    
+    def __repr__(self):
+        return self.__str__()
+
+KEYWORDS = {
+    'PROGRAM': Token('PROGRAM', 'PROGRAM'),
+    'VAR': Token('VAR', 'VAR'),
+    'INTEGER': Token('INTEGER', 'INTEGER'),
+    'REAL': Token('REAL', 'REAL'),
+    'DIV': Token('INTEGER_DIV', 'DIV'),
+    'BEGIN': Token('BEGIN', 'BEGIN'),
+    'END': Token('END', 'END'),
+    'FOR': Token('FOR', 'FOR'),
+    'TRUE': Token('TRUE', True),
+    'FALSE': Token('FALSE', False),
+    'IF': Token('IF', 'IF'),
+    'THEN': Token('THEN', 'THEN'),
+    'ELSE': Token('ELSE', 'ELSE'),
+    'PRINT': Token('PRINT', 'PRINT'),
+    'WHILE': Token('WHILE', 'WHILE'),
+    'DO': Token('DO', 'DO'),
+    'STRING': Token('STRING', 'STRING'),
+    'FUNCTION': Token('FUNCTION', 'FUNCTION'),
+    'RETURN': Token('RETURN', 'RETURN'),
+    'BY': Token('BY', 'BY'),
+    'TO': Token("TO", "TO"),
+    'BREAK': Token("BREAK", "BREAK"),
+     "INC" : Token("INC", "INC"),
+    "DEC" : Token("DEC","DEC"),
+    "LEN" : Token("LEN", "LEN"),
+    "LIST" : Token("LIST", "LIST"),
+    "NONE" : Token("NONE", "NONE"),
+    "APPEND" : Token("APPEND", "APPEND"),
+    "POP" : Token("POP", "POP"),
+    "HEAD" : Token("HEAD", "HEAD"),
+    "TAIL" : Token("TAIL", "TAIL"),
+    "ISEMPTY" : Token("ISEMPTY", "ISEMPTY")
+    # 'PRINT': Token('PRINT', ';'),
+    
+}
+
+
+class Lexer(object):
+    def __init__(self, text):
+        
+        self.text = text                        # stream of input
+        self.pos = 0                            # current position in the stream
+        self.lineNum = 1                        # line number in code
+        self.curLinePos = 0                     # current position in current line of program
+        if text == "":
+            print("Empty Program")
+            self.curChar = None
+            
+        else:
+            self.curChar = self.text[self.pos]      # current character in the stream
+        self.curLine = self.curChar             # current line of program read till now
+        
+
+    def error(self):
+        print("Current Character", self.curChar)
+        sys.exit('Invalid character')
+
+    def nextChar(self):                         # advances the pos pointer
+        self.pos += 1
+        self.curLinePos += 1
+        
+        if self.pos > len(self.text) - 1:       # end of input stream
+            self.curChar = None                 
+        else:
+            self.curChar = self.text[self.pos]
+            self.curLine += self.curChar
+            if self.curChar == '\n':
+                self.lineNum+=1
+                self.curLine=""
+                self.curLinePos=0
+        
+
+    def peek(self):                             # returns the lookahead character
+        if self.pos + 1 > len(self.text) - 1:
+            return None
+        else:
+            return self.text[self.pos + 1]
+
+    def skipSpaces(self):                       # to skip white spacses
+        while self.curChar is not None and self.curChar.isspace():
+            # if self.curChar == '\n':
+            #     self.lineNum+=1
+            #     self.curLine=""
+            #     self.curLinePos=0
+            self.nextChar()
+
+    def skipComments(self):
+        # while self.curChar != '}':
+        #     self.nextChar()
+        # self.nextChar()                         # to skip the closing curly brace as well
+        noOfstartBraces = 1
+        while noOfstartBraces != 0 :
+            self.nextChar()
+            if self.curChar == '{':
+                noOfstartBraces+=1
+            elif self.curChar == '}':
+                noOfstartBraces-=1
+            # self.skipSpaces()
+
+        self.nextChar()                         # to skip the closing curly brace as well
+
+    def scanSolution(self):
+        result = ''
+        while self.curChar != '$':
+            result += self.curChar
+            self.nextChar()
+        sys.stdout = open("solution.txt", "w") 
+        print(result)
+        sys.stdout = sys.__stdout__
+        self.nextChar()
+
+    def intlex(self):                           
+        # Consume all the consecutive digits and decimal if present.
+        result = ''
+        while self.curChar is not None and self.curChar.isdigit():
+            result += self.curChar
+            self.nextChar()
+
+        token = Token('INTEGER_CONST', int(result))
+        return token
+    
+    def number(self):                           
+        # Consume all the consecutive digits and decimal if present.
+        result = ''
+        while self.curChar is not None and self.curChar.isdigit():
+            result += self.curChar
+            self.nextChar()
+
+        if self.curChar == '.':
+            result += self.curChar
+            self.nextChar()
+
+            while (
+                self.curChar is not None and
+                self.curChar.isdigit()
+            ):
+                result += self.curChar
+                self.nextChar()
+
+            token = Token('REAL_CONST', float(result))
+        else:
+            token = Token('FRACTION_CONST', int(result))
+
+        return token
+
+    def _id(self):
+        # Handles identifiers and reserved keywords
+        result = ''
+        while self.curChar is not None and self.curChar.isalnum():
+            result += self.curChar
+            self.nextChar()
+
+        token = KEYWORDS.get(result, Token(ID, result))
+        return token
+    
+    def Stringlex(self):
+        # Handles strings
+        result = ''
+        while self.curChar != '"':
+            result += self.curChar
+            self.nextChar()
+        
+        self.nextChar()
+        token = Token('STRING', result)
+        return token
+
+    def get_token(self):
+        # returns the token and token type
+        while self.curChar is not None:
+
+            if self.curChar.isspace():
+                self.skipSpaces()
+                continue
+
+            if self.curChar == '{':
+                self.nextChar()
+                self.skipComments()
+                continue
+
+            if self.curChar == '$':
+                self.nextChar()
+                self.scanSolution()
+                continue
+
+            if self.curChar == '~':
+                if self.peek().isdigit():
+                    self.nextChar()                
+                    return self.intlex()
+                
+            if self.curChar.isalpha():
+                return self._id()
+
+            if self.curChar.isdigit():
+                return self.number()
+        
+            if self.curChar == ':':
+                if self.peek() == '=':
+                    self.nextChar()
+                    self.nextChar()
+                    return Token(ASSIGN, '=') # :=
+                else:
+                    self.nextChar()
+                    return Token(COLON, ':')
+                
+            if self.curChar == "|":
+                if self.peek() == "|":
+                    self.nextChar()
+                    self.nextChar()
+                    return Token(OR, "||")
+            
+
+            if self.curChar == "&":
+                if self.peek() == "&":
+                    self.nextChar()
+                    self.nextChar()
+                    return Token(AND, "&&")
+
+            if self.curChar == '>':
+                if self.peek() == '=':
+                    self.nextChar()
+                    self.nextChar()
+                    return Token(GTEQ, '>=')
+                else:
+                    self.nextChar()
+                    return Token(GT, '>')
+
+            if self.curChar == '<':
+                if self.peek() == '=':
+                    self.nextChar()
+                    self.nextChar()
+                    return Token(LTEQ, '<=')
+                elif self.peek() == '>':
+                    self.nextChar()
+                    self.nextChar()
+                    return Token(NOTEQ, '!=') # <>
+                else:
+                    self.nextChar()
+                    return Token(LT, '<')
+            
+            if self.curChar == '@':
+                if self.peek() == '=':
+                    self.nextChar()
+                    self.nextChar()
+                    return Token(POWEREQ, '**=')
+                else:
+                    self.nextChar()
+                    return Token(POWER, '**')
+                
+            if self.curChar == "%":
+                self.nextChar()
+                return Token(MODULO, '%')
+
+            if self.curChar == '=':
+                self.nextChar()
+                return Token(EQEQ, '==') # =
+
+            if self.curChar == '+':
+                if self.peek() == '=':
+                    self.nextChar()
+                    self.nextChar()
+                    return Token(PLUSEQ, '+=')
+                else:
+                    self.nextChar()
+                return Token(PLUS, '+')
+
+            if self.curChar == '-':
+                if self.peek() == '=':
+                    self.nextChar()
+                    self.nextChar()
+                    return Token(MINUSEQ, '-=')
+                else:
+                    self.nextChar()
+                return Token(MINUS, '-')
+
+            if self.curChar == '*':
+                if self.peek() == '=':
+                    self.nextChar()
+                    self.nextChar()
+                    return Token(MULEQ, '*=')
+                else:
+                    self.nextChar()
+                return Token(MUL, '*')
+
+            if self.curChar == '/':
+                if self.peek() == "=":
+                    self.nextChar()
+                    self.nextChar()
+                    return Token(FLOAT_DIVEQ, '/=')
+                if self.peek() == "/":
+                    self.nextChar()
+                    self.nextChar()
+                    return Token(INT_DIV, '//')                
+                else:
+                    self.nextChar()
+                return Token(FLOAT_DIV, '/')
+
+            if self.curChar == '(':
+                self.nextChar()
+                return Token(LPAREN, '(')
+
+            if self.curChar == ')':
+                self.nextChar()
+                return Token(RPAREN, ')')
+
+            if self.curChar == ';':
+                self.nextChar()
+                return Token(SEMI, ';')
+
+            if self.curChar == '.':
+                self.nextChar()
+                return Token(DOT, '.')
+
+            if self.curChar == ',':
+                self.nextChar()
+                return Token(COMMA, ',')
+            
+            if self.curChar == '"':
+                self.nextChar()
+                return self.Stringlex()  
+                    
+            if self.curChar == '[':
+                self.nextChar()
+                return Token(LSPAREN, '[')   
+            
+            if self.curChar == ']':
+                self.nextChar()
+                return Token(RSPAREN, ']')
+            self.error()
+
+        return Token(EOF, None)

lexer_input.txt

@@ -0,0 +1,25 @@
+PROGRAM lexercheck;
+VAR
+   a : INTEGER;
+   b : INTEGER;
+   c : INTEGER;
+   x : REAL;
+   y : REAL;
+
+BEGIN
+   IF (x = y)
+   THEN
+   a:= 5
+   z:= "happy"
+
+{ this is a comment}
+BEGIN
+   BEGIN
+      a := 4------3;
+      b := 5 * a
+      c := b DIV 4
+   END;
+   x := 1.1;
+   y := x / 4
+END.
+{ program is over}

lexer_test.py

@@ -0,0 +1,16 @@
+from lexer import *
+
+def main():
+
+    text = open("lexer_input.txt","r").read()
+    # text = "2 + 3 "
+    
+    lexer = Lexer(text)
+    Token = lexer.get_token()
+    while Token.type != EOF:
+        # print(Token.value, Token.type)
+        print(Token.__str__())
+        Token = lexer.get_token()
+    print(Token.value, Token.type)         # to check EOF
+
+main()

requirements.txt

@@ -0,0 +1,2 @@
+streamlit
+watchdog

resolved_tree

@@ -0,0 +1,5 @@
+Resolved Tree:
+Seq(statements=[Statement(command='print',
+                          statement=BinOp(operator='+',
+                                          left=NumLiteral(value=Fraction(3, 1)),
+                                          right=NumLiteral(value=Fraction(4, 1))))])

resolver.py

@@ -0,0 +1,243 @@
+from dataclasses_sim import *
+
+lateBinding = {}
+def resolve(program: AST, environment: Environment = None) -> AST:
+    if environment is None:
+        environment = Environment()
+    environment.program = program
+    def resolve_(program: AST) -> AST:
+        return resolve(program, environment)
+    
+    match program:
+        case IntLiteral(_) as I:
+            return I
+        case NumLiteral(_) as N:
+            return N
+        case BoolLiteral(_) as B:
+            return B
+        case StringLiteral(_) as SL:
+            return SL
+        case BinOp("=" as aop, MutVar(name) as m, right) :
+            r = resolve_(right)
+            if not environment.check(name):
+                environment.add(name, m)
+            else:
+                environment.update(name, m)
+            # environment.enter_scope()
+            m = resolve_(m)
+            mutvar = environment.get(name)
+            # r = resolve_(right)
+            mutvar.put(r)
+            
+            # environment.exit_scope()
+            return BinOp(aop, m, r)
+        case BinOp("+="as aop, MutVar(name)as m, right) | BinOp("-="as aop, MutVar(name)as m, right) | BinOp("/="as aop, MutVar(name)as m, right) | BinOp("*="as aop, MutVar(name)as m, right) | BinOp("**="as aop, MutVar(name)as m, right):
+            r = resolve_(right)
+            if not environment.check(name):
+                environment.add(name, m)
+            # environment.enter_scope()
+            m = resolve_(m)
+            mutvar = environment.get(name)
+            # r = resolve_(right)
+            mutvar.put(r)
+            
+            # environment.exit_scope()
+            return BinOp(aop, m, r)
+        case BinOp(o, left, right):
+            return BinOp(o, resolve_(left), resolve_(right))
+        case UnOp(o, mid):
+            return UnOp(o, resolve_(mid))
+        case Variable(name):
+            return environment.get(name)
+        case MutVar(name) as m :
+            if not environment.check(name):
+                environment.add(name, m)
+            return environment.get(name)
+        case Let(Variable(name) as v, e1, e2):
+            re1 = resolve_(e1)
+            environment.enter_scope()
+            environment.add(name, v)
+            re2 = resolve_(e2)
+            environment.exit_scope()
+            return Let(v, re1, re2)
+        case Statement(command ,statement):
+            return Statement(command, resolve_(statement))
+                
+                
+       
+
+        case IfElse(c, b, e):
+            return IfElse(resolve_(c), resolve_(b), resolve_(e))
+        case LetFun(Variable(name) as v, params, body, expr):
+            environment.enter_scope()
+            environment.add(name, v)
+            environment.enter_scope()
+            for param in params:
+                environment.add(param.name, param)
+            rbody = resolve_(body)
+            environment.exit_scope()
+            rexpr = resolve_(expr)
+            environment.exit_scope()
+            return LetFun(v, params, rbody, rexpr)
+        case Function(MutVar(name) as m, params , body) | Function(Variable(name) as m, params , body):
+            new = False
+            # environment.add(name, m)
+            if not environment.check(name):
+                environment.add(name, m)
+                if name in lateBinding:
+                    lateBinding[name].fn.id = m.id
+                    # lateBinding.pop(name)
+                    new = True
+            else:   
+                if name in lateBinding:
+                    lateBinding[name].fn.id = m.id
+                    lateBinding[name].fn.put(m.value)
+                    lateBinding.pop(name)
+                environment.update(name, m)
+            mutvar = environment.get(name)
+            
+            environment.enter_scope()
+            # rparams = []
+            for param in params:
+                environment.add(param.name, param)
+        
+                # rparams.append(resolve_(param))
+            rbody = resolve_(body)
+            environment.exit_scope()
+            e = FnObject(params, rbody)
+            mutvar.put(e)
+            if new:
+                lateBinding[name].fn.put(e)
+                lateBinding.pop(name)
+            return Function(mutvar, params, rbody)
+        case Seq(things):
+            environment.enter_scope()
+            v = []
+            for thing in things:
+                v.append(resolve_(thing))
+                
+            environment.exit_scope()
+            return Seq(v)
+        case FunCall(MutVar(name) as m, args):
+            if not environment.check(name):
+                lateBinding[name] = program
+            m = resolve_(m)
+            fn = environment.get(name).get()
+            m.put(fn)
+            argv = []
+            
+            for arg in args:
+                argv.append(resolve_(arg))
+            return FunCall(m, argv)
+        case FunCall(fn, args):
+            rfn = resolve_(fn)
+            rargs = []
+            for arg in args:
+                rargs.append(resolve_(arg))
+            return FunCall(rfn, rargs)
+        
+            
+        case While(c, b):
+            
+            return While(resolve_(c), resolve_(b))
+        case ForLoop(start, condition, increment, body):
+            return ForLoop(resolve_(start), resolve_(condition), resolve_(increment), resolve_(body))
+        
+        case Listing(value, datatype):
+            for i in range(len(value)):
+                value[i] = resolve_(value[i])
+            return Listing(value, datatype)
+        
+        case Slicing(name, start, end, jump):   
+            return Slicing(resolve_(name), resolve_(start), resolve_(end), resolve_(jump))
+        
+        case list_append(MutVar(var), item):
+            if not environment.check(var):
+                environment.add(var, MutVar(var))
+            return list_append(environment.get(var), resolve_(item))
+        case length(MutVar(var)):
+            if not environment.check(var):
+                environment.add(var, MutVar(var))
+            return length(resolve_(environment.get(var)))
+        case Increment(MutVar(var)):
+            return Increment(resolve_(environment.get(var)))
+        case Decrement(MutVar(var)):
+            return Decrement(resolve_(environment.get(var)))
+
+        
+
+
+        
+# def eval(program: AST, environment: Environment = None) -> Value:
+#     if environment is None:
+#         environment = Environment()
+
+#     def eval_(program):
+#         return eval(program, environment)
+
+#     match program:
+#         case NumLiteral(value):
+#             return value
+#         case Variable(_) as v:
+#             return environment.get(v)
+#         case Let(Variable(_) as v, e1, e2) | LetMut(Variable(_) as v, e1, e2):
+#             v1 = eval_(e1)
+#             environment.enter_scope()
+#             environment.add(v, v1)
+#             v2 = eval_(e2)
+#             environment.exit_scope()
+#             return v2
+#         case BinOp("+", left, right):
+#             return eval_(left) + eval_(right)
+#         case BinOp("-", left, right):
+#             return eval_(left) - eval_(right)
+#         case BinOp("*", left, right):
+#             return eval_(left) * eval_(right)
+#         case BinOp("/", left, right):
+#             return eval_(left) / eval_(right)
+#         case Put(Variable(_) as v, e):
+#             environment.update(v, eval_(e))
+#             return environment.get(v)
+#         case Get(Variable(_) as v):
+#             return environment.get(v)
+#         case Seq(things):
+#             v = None
+#             for thing in things:
+#                 v = eval_(thing)
+#             return v
+#         case LetFun(Variable(_) as v, params, body, expr):
+#             environment.enter_scope()
+#             environment.add(v, FnObject(params, body))
+#             v = eval_(expr)
+#             environment.exit_scope()
+#             return v
+#         case FunCall(Variable(_) as v, args):
+#             fn = environment.get(v)
+#             argv = []
+#             for arg in args:
+#                 argv.append(eval_(arg))
+#             environment.enter_scope()
+#             for param, arg in zip(fn.params, argv):
+#                 environment.add(param, arg)
+#             v = eval_(fn.body)
+#             environment.exit_scope()
+#             return v
+#     raise InvalidProgram()
+
+def test_resolve():
+    import pprint
+    pp = pprint.PrettyPrinter(indent=4)
+    e = Let(Variable.make("a"), NumLiteral(0), Variable.make("a"))
+    # pp.pprint(e)
+    re = resolve(e)
+    # pp.pprint(re)
+
+    e = LetFun(Variable.make("foo"), [Variable.make("a")], FunCall(Variable.make("foo"), [Variable.make("a")]),
+               Let(Variable.make("g"), Variable.make("foo"),
+                   LetFun(Variable.make("foo"), [Variable.make("a")], NumLiteral(0),
+                          FunCall(Variable.make("g"), [NumLiteral(0)]))))
+    pp.pprint(e)
+    pp.pprint(r := resolve(e))
+    print(eval(r))
+
+# test_resolve()

sim.py

@@ -0,0 +1,893 @@
+from dataclasses_sim import *
+import Parser as prs
+from type_checking import *
+from resolver import *
+import sys
+import pprint
+import copy
+pp = pprint.PrettyPrinter()
+
+def type_error():
+        sys.exit('Dynamic type check error')
+
+# Combining lexer parser
+@dataclass
+class Interpreter:
+    parser: prs.Parser
+
+def eval(program: AST, environment: Environment() = None) -> Value:
+    if environment is None:
+        environment = Environment()
+    environment.program = program
+    def eval_env(program):
+        return eval(program, environment)
+    
+    def eval_bool_env(program):
+        return eval_bool(program, environment)
+    
+    def eval_string_env(program):
+        return eval_string(program, environment)
+
+    match program:
+        case Interpreter(p):
+            tree = p.parse()
+            sys.stdout = open('unresolved_tree', 'w')
+            pp = pprint.PrettyPrinter(stream=sys.stdout)
+            print("Unresolved Tree:")
+            pp.pprint(tree)
+            
+            if resolverOn:
+                tree = resolve(tree)
+                sys.stdout = open('resolved_tree', 'w')
+                pp = pprint.PrettyPrinter(stream=sys.stdout)
+                pp.stream = sys.stdout
+                print("Resolved Tree:")
+                pp.pprint(tree)
+
+            # typecheck(tree)
+            sys.stdout = open('eval.txt', 'w')
+            e = eval(tree)
+            sys.stdout = sys.__stdout__
+
+            return e
+        
+        
+        case Statement(command ,statement):
+            match command:
+                case "print":
+                    # print(statement)
+                    if isinstance(statement,StringLiteral) :
+                        print(eval_string_env(statement))
+                    elif isinstance(statement, type(None)):
+                        print()
+                    elif isinstance(statement, MutVar):
+                        e = environment.get(statement.name).get()
+                        if isinstance(e, Listing):
+                            print(eval_env(e))
+                        else:
+                            print(e)
+
+                    else:
+                        e = eval_env(statement)
+                        if isinstance(e, Listing):
+                            print(eval_env(e))
+                        
+                        else:
+                            print(e)
+                        # print(eval_env(statement)) 
+                case "return":
+                    e = Statement(command, statement)
+
+                    if isinstance(statement,StringLiteral) :
+                        
+                        e.statement = eval_string_env(statement)
+                        
+                    else:
+                        e.statement = eval_env(statement)
+                    return e
+                case "break":
+                    return program  
+                
+            return 
+
+        case IfElse(c, b, e):
+            match eval_env(c):
+                case True: 
+                    return eval_env(b)
+                case False: 
+                    if e == None:
+                        return
+                    return eval_env(e)
+
+        case Put(Variable(name), e):
+            environment.update(name, eval_env(e))
+            return environment.get(name)
+        case Get(Variable(name)):
+            return environment.get(name)
+        
+        case Put(MutVar(name), e):
+            MutVar(name).put(eval(e))
+            environment.update(name,MutVar(name))
+            return MutVar(name).get()
+        
+        case Get(MutVar(name)):
+            return environment.get(name).get()
+        
+        case Seq(things):
+            environment.enter_scope()
+            v = None
+            for thing in things:
+                v = eval_env(thing)
+                if isinstance(v,Statement):
+                    if v.command=="break":
+                        break
+                    if v.command=="return":
+                         return v.statement
+            environment.exit_scope()
+            return v    
+        
+        case LetFun(Variable(name), params, body, expr):
+            environment.enter_scope()
+            environment.add(name, FnObject(params, body))
+            v = eval_env(expr)
+            environment.exit_scope()
+            return v
+        
+        case FunCall(Variable(name), args):
+            fn = environment.get(name)
+            argv = []
+            for arg in args:
+                argv.append(eval_env(arg))
+            environment.enter_scope()
+            for param, arg in zip(fn.params, argv):
+                environment.add(param.name, arg)
+            v = eval_env(fn.body)
+            environment.exit_scope()
+            return v
+        
+        case FunCall(MutVar(name) as m, args):
+            # not (environment.check(name) and environment.get(name) != None)
+            if m.value == None and (not environment.check(name) or environment.get(name) == None):
+                print(f"Function '{name}' not defined")
+                sys.exit()
+                # environment.add(name, MutVar(name))
+                # environment.get(name).put(FnObject([],None))
+            
+            m.value = copy.deepcopy(m.value)
+            fn = m.value if m.value != None else environment.get(name).get() #fn is FnObject
+            # pp = pprint.PrettyPrinter()
+            # pp.pprint(fn)
+            # pp.pprint(environment.envs)
+            # fn = FnObject(fn.params, fn.body)
+            argv = []
+            mtfo = [] #muttable function object
+            for arg in args:
+                if arg != None:
+                    mtfo.append(arg)
+                    #if isinstance(arg, MutVar) and isinstance(arg.value, FnObject):
+                        # mtfo[arg.value] = arg
+                    argv.append(eval_env(arg))
+            environment.enter_scope()
+            # print(name)
+            # print(argv)
+            # print(mtfo)
+            # print(fn.params)
+            # print(fn.body)
+            for param, arg in zip(fn.params, argv):
+                if isinstance(param, MutVar):
+                    if isinstance(arg, FnObject):
+                        e = mtfo[argv.index(arg)]
+                        if environment.check(e.name):
+                            environment.addWithOther(e.name, param.name, None)
+                        # param.put(FnObject(arg.params, copy.deepcopy(arg.body)))
+                        # param.put(copy.deepcopy(arg))
+                        
+                    else:
+                        environment.add(param.name, param)
+                    param.put(arg)
+                else:
+                    environment.add(param.name, arg)
+            # print(fn, id(fn.body))
+            v = eval_env(fn.body)
+            
+            environment.exit_scope()
+            # print(name, v)
+            return v
+        
+        case FunCall(FunCall(_,_) as funcall, args):
+            # print(fncall)
+            fn = eval_env(funcall)
+            
+            # not (environment.check(name) and environment.get(name) != None)
+            # if m.value == None and (not environment.check(name) or environment.get(name) == None):
+            #     print(f"Function '{name}' not defined")
+            #     sys.exit()
+            #     # environment.add(name, MutVar(name))
+            #     # environment.get(name).put(FnObject([],None))
+            # m.value = copy.deepcopy(m.value)
+            # fn = m.value if m.value != None else environment.get(name).get() #fn is FnObject
+            # fn = FnObject(fn.params, fn.body)
+            argv = []
+            mtfo = [] #muttable function object
+            for arg in args:
+                if arg != None:
+                    mtfo.append(arg)
+                    #if isinstance(arg, MutVar) and isinstance(arg.value, FnObject):
+                        # mtfo[arg.value] = arg
+                    argv.append(eval_env(arg))
+            environment.enter_scope()
+            # print(name)
+            # print(argv)
+            # print(mtfo)
+            # print(fn.params)
+            # print(fn.body)
+            for param, arg in zip(fn.params, argv):
+                if isinstance(param, MutVar):
+                    if isinstance(arg, FnObject):
+                        e = mtfo[argv.index(arg)]
+                        if environment.check(e.name):
+                            environment.addWithOther(e.name, param.name, None)
+                        # param.put(FnObject(arg.params, copy.deepcopy(arg.body)))
+                        # param.put(copy.deepcopy(arg))
+                        
+                    else:
+                        environment.add(param.name, param)
+                    param.put(arg)
+                else:
+                    environment.add(param.name, arg)
+            # print(fn, id(fn.body))
+            v = eval_env(fn.body)
+            
+            environment.exit_scope()
+            return v
+        
+        case MutVar(name) as m:
+            # if program.value != None:
+            #     return program.get()
+                
+            # return
+            if not environment.check(name):
+                print(environment.envs)
+                print(f"Mutable Variable '{name}' not defined")
+                sys.exit()
+                # environment.add(name, MutVar(name))
+            
+            e = m if m.value != None else environment.get(name)
+            # e = environment.get(name)
+            v = e.get()
+            typesWithNoEval = Fraction | FnObject | Listing | int | float | str | bool
+            # if isinstance(v, Fraction) or isinstance(v, FnObject) or isinstance(v, Listing):
+            if isinstance(v, typesWithNoEval):
+                return v
+            else:
+                v = eval_env(v)
+                # e.put(v)
+                return v
+
+        case Increment(MutVar(name)):
+            #print('Hi')
+            temp = environment.get(name)
+            e = eval_env(temp)
+            #print('Hi')
+            e = e + eval_env(NumLiteral(1))
+            temp.put(e)
+            environment.update(name, temp)
+            return 
+        
+        case Decrement(MutVar(name)):
+            temp = environment.get(name)
+            e = eval_env(temp)
+            e = e - eval_env(NumLiteral(1))
+            temp.put(e)
+            environment.update(name, temp)
+            return 
+        
+        case length(MutVar(name)):
+            temp = environment.get(name).get()
+            # e = eval_env(temp)
+            # return len(e.value)
+            if isinstance(temp, Listing):
+                return len(temp.value)
+            return len(temp)
+
+        case list_head(MutVar(name)):
+            temp = environment.get(name)
+            e = eval_env(temp)
+            return e[0]
+        
+        case list_tail(MutVar(name)):
+            temp = environment.get(name)
+            e = eval_env(temp)
+            return e[1:]
+        
+        case list_isempty(MutVar(name)):
+            temp = environment.get(name)
+            e = eval_env(temp)
+            if len(e)==0:
+                return True
+            return False
+        
+        case list_append(MutVar(var), item):
+         
+            if not environment.check(var):
+                print(f"list '{var}' not defined")
+                sys.exit()
+            temp = environment.get(var).get().value
+            # e1 = eval_env(temp)
+            # e1.append(eval_env(item))
+            e1 = temp
+            e1.append(item)
+            return e1
+
+
+        
+        case Listing(value, datatype):
+            if datatype != "NONE":
+                if datatype == "INTEGER":
+                    temp = IntLiteral
+                elif datatype == "STRING":
+                    temp = StringLiteral
+                elif datatype == "NONE":
+                    temp = None
+                for i in value:
+                    if isinstance(i, temp):
+                        continue
+                    else:
+                        print("Value of Invalid type in Listing")
+                        raise InvalidProgram()
+       
+            temp =[]
+            for i in program.value:
+                temp.append(eval_env(i))
+       
+
+            return temp
+
+
+        case Slicing(name, start, end, jump):      
+             
+            e1 = eval_env(name)
+            if isinstance(e1, Listing):
+                e1 = eval_env(e1)
+            e2 = eval_env(start)
+            e2 = int(e2)
+            if end!=None:
+                e3 = eval_env(end)
+                e3  = int(e3)
+
+            if jump!=None:
+                e4 = eval_env(jump)
+                e4  = int(e4)
+    
+            if end == None and jump!=None:
+                e = e1[e2::e4]
+            elif jump==None:
+                e = e1[e2]
+            else:
+                e = e1[e2:e3:e4]
+            return e
+        
+        case list_Slicing(name, start, end, jump):       
+            e1 = eval_env(name)
+            e2 = eval_env(start)
+            e2 = int(e2)
+            if end!=None:
+                e3 = eval_env(end)
+                e3  = int(e3)
+
+            if jump!=None:
+                e4 = eval_env(jump)
+                e4  = int(e4)
+    
+            if end == None and jump!=None:
+                e = e1[e2::e4]
+            elif jump==None:
+                e = e1[e2]
+            else:
+                e = e1[e2:e3:e4]
+            return e
+        
+
+        case ForLoop(start, condition, increment, body):
+            # print("Zeeshan", condition)
+
+            eval_env(start)
+            if(condition == None):
+                while True:
+                    v = eval_env(body)
+                    if isinstance(v,Statement):
+                        if v.command=="break":
+                            break
+                        if v.command=="return":
+                            return v.statement
+                    else:
+                        eval_env(increment)
+            else:
+                while(eval_env(condition)):
+                    v = eval_env(body)
+                    if isinstance(v,Statement):
+                        if v.command=="break":
+                            break
+                        if v.command=="return":
+                            return v.statement
+                    else:
+                        eval_env(increment)
+            return
+        
+
+        # def for_loop_helper(en, condition):
+        # # print(jump)
+        # flag = eval_env(condition)
+        # # if(flag < en):
+        # #     eval_env(body)
+        # #     return for_loop_helper(en, jump)
+        # # while(flag != en):
+        # #     eval_env(body)
+        # #     flag = eval_env(condition)
+        # while(eval_env(condition)):
+        #     eval_env(body)
+        #     eval_env(en)
+        # return
+
+        case While(c, b):
+            # if eval_bool_env(c):
+            #     eval_env(b)
+            #     eval_env(While(c, b))
+            while (eval_env(c)): # avoid recursion depth
+                v = eval_env(b)
+                if isinstance(v,Statement):
+                    if v.command=="break":
+                        break
+                    if v.command=="return":
+                        return v.statement
+            return 
+
+        case BinOp("=", MutVar(name) as m, val):
+            if (not isinstance(val, Listing)):
+                e = eval_env(val)
+            else:
+                e = val
+
+            program.right = val
+            # e = eval_env(val)
+            # program.get_left().put(eval(val))
+            if not environment.check(name):
+                environment.add(name, m)
+                mutvar = environment.get(name)
+                mutvar.put(e)
+
+            else:
+                mutvar = environment.get(name)
+                # environment.update(name, MutVar(name))
+                mutvar.put(e)
+                m.put(e)
+            return mutvar.get() #Assignment as expression
+        
+        case BinOp("+=", MutVar(name) as m, val):
+            e = eval_env(val) 
+            # program.get_left().put(eval(val))
+            if not environment.check(name):
+                environment.add(name, m)
+                mutvar = environment.get(name)
+                e += mutvar.get()
+                mutvar.put(e)
+
+            else:
+                mutvar = environment.get(name)
+                e += mutvar.get()
+                # environment.update(name, MutVar(name))
+                mutvar.put(e)
+            return mutvar.get() #Assignment as expression
+        
+
+        case BinOp("-=", MutVar(name) as m, val):
+            e = eval_env(val) 
+            # program.get_left().put(eval(val))
+            if not environment.check(name):
+                environment.add(name, m)
+                mutvar = environment.get(name)
+                e -= mutvar.get()
+                mutvar.put(e)
+
+            else:
+                mutvar = environment.get(name)
+                e -= mutvar.get()
+                # environment.update(name, MutVar(name))
+                mutvar.put(e)
+            return mutvar.get() #Assignment as expression
+        
+
+    
+        case BinOp("/=", MutVar(name) as m, val):
+            e = eval_env(val) 
+            # program.get_left().put(eval(val))
+            if not environment.check(name):
+                environment.add(name, m)
+                mutvar = environment.get(name)
+                e /= mutvar.get()
+                mutvar.put(e)
+
+            else:
+                mutvar = environment.get(name)
+                e /= mutvar.get()
+                # environment.update(name, MutVar(name))
+                mutvar.put(e)
+            return mutvar.get() #Assignment as expression
+        
+        case BinOp("*=", MutVar(name) as m, val):
+            e = eval_env(val) 
+            # program.get_left().put(eval(val))
+            if not environment.check(name):
+                environment.add(name, m)
+                mutvar = environment.get(name)
+                e *= mutvar.get()
+                mutvar.put(e)
+
+            else:
+                mutvar = environment.get(name)
+                e *= mutvar.get()
+                # environment.update(name, MutVar(name))
+                mutvar.put(e)
+            return mutvar.get() #Assignment as expression
+
+        case BinOp("**=", MutVar(name) as m, val):
+            e = eval_env(val) 
+            # program.get_left().put(eval(val))
+            if not environment.check(name):
+                environment.add(name, m)
+                mutvar = environment.get(name)
+                e **= mutvar.get()
+                mutvar.put(e)
+
+            else:
+                mutvar = environment.get(name)
+                e **= mutvar.get()
+                # environment.update(name, MutVar(name))
+                mutvar.put(e)
+            return mutvar.get() #Assignment as expression
+        
+
+    
+        case Function(MutVar(name) as m, params , body) | Function(Variable(name) as m, params , body):
+            # environment.enter_scope()
+            # environment.add(name, FnObject(params, body))
+            if not environment.check(name):
+                environment.add(name, m)
+            else:
+                environment.update(name, m)
+            mutvar = environment.get(name)
+            e = FnObject(params, body)
+            mutvar.put(e)
+            
+            # if isinstance(program.name, MutVar):
+            #     program.name.put(FnObject(params, body))
+            # environment.exit_scope()
+            return e
+
+        case NumLiteral(val):
+            return val
+        case IntLiteral(val):
+            return val
+        case FloatLiteral(val):
+            return val
+        case BoolLiteral(val):
+            return eval_bool_env(program)
+        case StringLiteral(val):
+            return eval_string_env(program)
+        
+        
+        case Variable(name):
+            # print(environment)
+            # if name in environment:
+            #     return environment[name]
+            # raise InvalidProgram()
+            return environment.get(name)
+        
+        # case Let(Variable(name), e1, e2):
+        #     v1 = eval_env(e1)
+        #     return eval(e2, environment | { name: v1})
+
+        case Let(Variable(name), e1, e2) | LetMut(Variable(name), e1, e2) | Let(MutVar(name), e1, e2):
+            # v1 = eval_env(e1)
+            # return eval(e2, environment | { name: v1})
+            v1 = eval_env(e1)
+            environment.enter_scope()
+            environment.add(name, v1)
+            v2 = eval_env(e2)
+            environment.exit_scope()
+            return v2
+        
+        
+        case BinOp("+", left, right):
+            # if (isinstance(right, NumLiteral) == False):
+            #     type_error()
+            return eval_env(left) + eval_env(right)
+        case BinOp("-", left, right):
+            return eval_env(left) - eval_env(right)
+        case BinOp("*", left, right):
+            return eval_env(left) * eval_env(right)
+        case BinOp("/", left, right):
+            return eval_env(left) / eval_env(right)
+        case BinOp("//", left, right):
+            return eval_env(left) // eval_env(right)
+        case BinOp("%", left, right):
+            return eval_env(left) % eval_env(right)
+        case UnOp("-", mid):
+            return Fraction(-1)*eval(mid)
+        case UnOp("+", mid):
+            return eval(mid)
+        case UnOp("++", mid):
+            return eval_env(mid)+Fraction(1)
+        case UnOp("--", mid):
+            return eval_env(mid)-Fraction(1)
+        case BinOp("<<", left, right):
+            try:
+                if(eval_env(right) < 0):
+                    raise InvalidProgram(Exception)
+            except InvalidProgram:
+                print("Shift operator must be non negative") 
+            return int(eval_env(left)) << int(eval_env(right))
+        case BinOp(">>", left, right):
+            try:
+                if(eval_env(right) < 0):
+                    raise InvalidProgram(Exception)
+            except InvalidProgram:
+                print("Shift operator must be non negative") 
+            return int(eval_env(left)) >> int(eval_env(right))
+        case BinOp("|", left, right):
+            return eval_env(left) | eval_env(right)
+        case BinOp("&", left, right):
+            return eval_env(left) & eval_env(right)
+        case BinOp("^", left, right):
+            return eval_env(left) ^ eval_env(right)
+        case BinOp("**", left, right):
+            return eval_env(left) ** eval_env(right)
+        case _:
+            return eval_string_env(program)
+
+    raise InvalidProgram()
+
+
+def eval_string(program: AST, environment: Environment() = None) -> str:
+    if environment is None:
+        environment = Environment()
+
+    def eval_env(program):
+        return eval(program, environment)
+    
+    def eval_bool_env(program):
+        return eval_bool(program, environment)
+    
+    def eval_string_env(program):
+        return eval_string(program, environment)
+
+    match program:
+        
+        case StringLiteral(val):
+            return val
+        case BinOp("=", MutVar(name), val):
+            e = eval_string_env(val)
+            # program.get_left().put(eval(val))
+            if not environment.check(name):
+                environment.add(name, MutVar(name))
+                mutvar = environment.get(name)
+                mutvar.put(e)
+
+            else:
+                mutvar = environment.get(name)
+                # environment.update(name, MutVar(name))
+                mutvar.put(e)
+            return
+        
+        case BinOp("+", left, right):
+            return left + right
+        # case BinOp("")
+        case _:
+            return eval_bool_env(program)
+
+    raise InvalidProgram()
+    
+
+def eval_bool(program: AST, environment: Environment() = None) -> Val:
+    if environment is None:
+        environment = Environment()
+
+    def eval_env(program):
+        return eval(program, environment)
+    def eval_bool_env(program):
+        return eval_bool(program, environment)
+    
+    def eval_string_env(program):
+        return eval_string(program, environment)
+    match program:
+        
+        case BoolLiteral(value):
+            return value
+        case BinOp("==", left, right):
+            return (eval_env(left)==eval_env(right))
+        case BinOp(">", left, right):
+            return (eval_env(left)>eval_env(right))
+        case BinOp("<", left, right):
+            return (eval_env(left)<eval_env(right))
+        case BinOp(">=", left, right):
+            return (eval_env(left)>=eval_env(right))  
+        case BinOp("<=", left, right):
+            return (eval_env(left)<=eval_env(right))  
+        case BinOp("!=", left, right):
+            return (eval_env(left)!=eval_env(right))
+        case UnOp("!", mid):
+            return (not eval_env(mid))
+        case BinOp("&&", left, right):
+            return eval_env(left) and eval_env(right)
+        case BinOp("||", left, right):
+            return eval_env(left) or eval_env(right) 
+        
+    sys.stdout = open('error_in_sim', 'w')    
+    pp = pprint.PrettyPrinter(stream=sys.stdout)
+    print("Current AST")   
+    pp.pprint(program)
+    
+    print("Current Environment:")
+    
+    pp.pprint( environment.envs)
+    raise InvalidProgram()  
+
+
+def test_eval():
+    e1 = NumLiteral(2)
+    e2 = NumLiteral(7)
+    e3 = NumLiteral(9)
+    e4 = NumLiteral(5)
+    e5 = BinOp("+", e2, e3)
+    e6 = BinOp("/", e5, e4)
+    e7 = BinOp("*", e1, e6)
+    assert eval(e7) == Fraction(32, 5)
+
+def test_let_eval():
+    a  = Variable("a")
+
+    e1 = NumLiteral(5)
+    e2 = BinOp("+", a, a)
+    e  = Let(a, e1, e2)
+    assert eval(e) == 10
+    e  = Let(a, e1, Let(a, e2, e2))
+    assert eval(e) == 20
+    e  = Let(a, e1, BinOp("+", a, Let(a, e2, e2)))
+    assert eval(e) == 25
+    e  = Let(a, e1, BinOp("+", Let(a, e2, e2), a))
+    assert eval(e) == 25    
+    e3 = NumLiteral(6)
+    e  = BinOp("+", Let(a, e1, e2), Let(a, e3, e2))
+    assert eval(e) == 22
+
+# test_let_eval()
+
+def test_letmut():
+    a = Variable("a")
+    b = Variable("b")
+    e1 = LetMut(b, NumLiteral(2), Put(a, BinOp("+", Get(a), Get(b))))
+    e2 = LetMut(a, NumLiteral(1), Seq([e1, Get(a)]))
+    assert eval(e2) == 3
+
+# test_letmut()
+
+def test_Logic():
+    x1 = NumLiteral(5)
+    x2 = NumLiteral(3)
+    x3 = BinOp(">=",x1,x2)
+    x4 = BinOp("<",x1,x2)
+    x5 = BinOp("+", x1, x2)
+    e = BinOp("<<", x1, x2)
+    assert eval(e) == 40
+    assert eval_bool(x3) == True
+    assert eval_bool(x4) == False
+    x1 = BoolLiteral(True)
+    x2 = BoolLiteral(False)
+    e = BinOp("&&", x1, x2)
+    # print(e)
+    assert eval_bool(e) == False
+    e = UnOp("!", BoolLiteral(True))
+    # print(eval_bool(e)) 
+    assert eval_bool(e) == False  
+
+    # assert eval_bool(e) == False
+    # e = UnOp("!", False)
+    # assert eval_bool(e) == True
+    e = Statement("print", x5)
+    eval(e)
+
+    e = Statement("print",StringLiteral("karthikeya"))
+    eval(e)
+
+    # print("print(\"karthikeya\")".split())
+    # print("")
+
+# test_Logic()
+
+def test_IfElse():
+    a = NumLiteral(2)
+    b = NumLiteral(5)
+    c = Variable('c')
+    x1 = BinOp("==", a, b)
+    x2 = Let(c,BinOp("+", a, b),c)
+    x3 = Let(c,BinOp("*", a, b),c)
+    e1 = IfElse(x1, x2, x3)
+    print(eval(e1))
+    # print(eval(c))
+
+# test_IfElse()
+
+def test_While():
+    p = MutVar('p')
+    p_g = BinOp("=", p, NumLiteral(1))
+    i = MutVar('i')
+    i_g = BinOp("=", i, NumLiteral(1))
+    
+    # print(p.get(), i.get())
+    cond = BinOp("<=", i, NumLiteral(10))
+    x1 = BinOp("*", p, i)
+    x2 = BinOp("+", i, NumLiteral(1))
+    x3 = BinOp("=", p, x1)
+    x4 = BinOp("=", i, x2)
+    e = Seq([p_g, i_g,While(cond, Seq([x3, x4]))])
+    eval(e)
+    print(p.get(), i.get())
+
+# test_While()
+
+def test_MutVar_Get_Put():
+    p = MutVar('p')
+    p_g = BinOp("=", p, NumLiteral(1))
+    i = MutVar('i')
+    i_g = BinOp("=", i, NumLiteral(1))
+    e = Seq([p_g, i_g, Statement('print',Get('i')), Statement('print',Get('p')) ])
+# test_MutVar_Get_Put()
+
+def test_Function():
+    e1 = BinOp("+", NumLiteral(2), NumLiteral(1))
+    f1 = Function('add', e1, [])
+    e2 = BinOp("-", NumLiteral(2), NumLiteral(1))
+    f2 = Function('sub', e2, [])
+    eval(f1)
+    eval(f2)
+    e = Seq([f1,f2,])
+
+
+# test_Function()
+
+def test_letfun():
+    a = Variable("a")
+    b = Variable("b")
+    f = Variable("f")
+    g = BinOp (
+        "*",
+        FunCall(f, [NumLiteral(15), NumLiteral(2)]),
+        FunCall(f, [NumLiteral(12), NumLiteral(3)])
+    )
+    e = LetFun(
+        f, [a, b], BinOp("+", a, b),
+        g
+    )
+    assert eval(e) == (15+2)*(12+3)
+    print(eval(e))
+
+# test_letfun()
+
+def test_letfun2():
+    fact = Variable("fact")
+    g = Variable("g")
+    n = Variable("n")
+    e2 = LetFun(fact, [n], NumLiteral(0), FunCall(g, [NumLiteral(3)] ))
+    e1 = LetFun(g, [n], FunCall(fact, [n]), e2)
+    e = LetFun(fact, [n], 
+               IfElse(BinOp("==",n,NumLiteral(0)),
+                      NumLiteral(1),
+                      FunCall(fact, [BinOp("-",n, NumLiteral(1))])), 
+                e1)
+    print(eval(e))
+
+
+
+
+
+# test_letfun2()

solution.txt

@@ -0,0 +1,35 @@
+1
+2
+FIZZ
+4
+BUZZ
+FIZZ
+7
+8
+FIZZ
+BUZZ
+11
+FIZZ
+13
+14
+FIZZ BUZZ
+16
+17
+FIZZ
+19
+BUZZ
+FIZZ
+22
+23
+FIZZ
+BUZZ
+26
+FIZZ
+28
+29
+FIZZ BUZZ
+31
+32
+FIZZ
+34
+BUZZ

sum_of_two_million_primes.txt

@@ -0,0 +1,32 @@
+
+BEGIN
+sum := 0;
+FOR i := 2 ; i < 2000000 ; i := i + 1
+DO
+    BEGIN
+    flag := 0;
+    FOR j := 2 ; j <= i@(1/2) ; j := j + 1
+        DO
+            BEGIN
+            IF i % j = 0
+                THEN
+                    BEGIN
+                    flag := 1;
+                    BREAK;
+                    END
+                ELSE
+                    END
+            END
+        END;
+    IF flag = 0
+        THEN
+            BEGIN
+            { PRINT i END;}
+            sum := sum + i;
+            END
+        ELSE
+            END
+    END
+    END;
+PRINT sum END;
+END

testing.py

@@ -0,0 +1,90 @@
+import lexer as lex
+# import Parser as prs
+from sim import *
+import time
+
+# Combining lexer parser
+# text = "IF 2 > 1 THEN 3+5 ELSE 41 END"
+# text = "a := 3"
+# text = "BEGIN PRINT 4+4 END; PRINT 7 END; END"
+# text = """
+#         BEGIN 
+#             i:=1;
+#             j:=1;
+#             PRINT i END; 
+#             WHILE i<6
+#             DO 
+#                 BEGIN 
+#                 j:=j*i;
+#                 i:=i+1;   
+#                 PRINT j END;            
+#                 PRINT i END;
+
+#                 END
+#             END;
+#             j:=j*i;
+#             PRINT j END;
+#         END"""
+
+# text =  """
+#         k:="stri";
+#         """
+
+# text = "-2*(1---2)"
+
+# text = """PRINT 3 < 6 && 4 < 3 END""" 
+
+    # for i:= 1 to 10 by 1 do writeln(i);
+# text = """BEGIN 
+#             p:=1;
+#             q:=1;
+#             FOR i:= 1 TO 1560 BY i := i + 1 
+#             DO 
+#                 BEGIN 
+#                 q:=q*p;
+#                 p:=p+1;   
+#                 {PRINT p END;}          
+#                 PRINT q END;
+#                 PRINT i END;
+#                 END 
+#             END; 
+#         END""" 
+# text = """BEGIN
+#         IF 3 % 4 = 0 || 3 % 5 = 0 THEN BEGIN PRINT 5 END; END ELSE BEGIN PRINT 6 END; END END;
+#         IF 3 % 4 = 0 || 5 % 5 = 0 THEN BEGIN PRINT 5 END; END ELSE BEGIN PRINT 6 END; END END;
+#         IF 4 % 4 = 0 && 3 % 5 = 0 THEN BEGIN PRINT 5 END; END ELSE BEGIN PRINT 6 END; END END;
+#         END
+#         """
+# text = """
+#         BEGIN
+#             p := 2;
+#            {PRINT 2@3@2 END;}
+#             PRINT 4@3@2 END;
+#             a:=3@2;
+#             {p := p @ 3;}
+#             PRINT 4@a END;
+#             PRINT a END;
+#         END
+#         """
+start = time.time()
+
+text = open("input.txt","r").read()
+# text = "PRINT 3@(1/2) END"
+# text = "3 > 4"
+# text = "-2*(1---2)"
+# text = "PRINT 2-+ +3 END"
+# if len(text) != 0:
+text = "BEGIN "+text+" END"
+
+l = lex.Lexer(text)   
+p = prs.Parser(l)
+i = Interpreter(p)
+# print(eval(i))
+
+eval(i)
+# print(open("eval.txt").read()==open("solution.txt").read())
+print("Time taken", time.time()-start)
+
+# test_While()
+# test_Logic()
+# test_resolve()

type_checking.py

@@ -0,0 +1,97 @@
+# from fractions import Fraction
+# from dataclasses import dataclass
+# from typing import Optional, NewType
+from dataclasses_sim import *
+# A minimal example to illustrate typechecking.
+
+# @dataclass
+# class NumType:
+#     pass
+
+# @dataclass
+# class BoolType:
+#     pass
+
+# SimType = NumType | BoolType
+
+# @dataclass
+# class NumLiteral:
+#     value: Fraction
+# #     type: SimType = NumType()
+
+# @dataclass
+# class BoolLiteral:
+#     value: bool
+# #     type: SimType = BoolType()
+
+# @dataclass
+# class BinOp:
+#     operator: str
+#     left: 'AST'
+#     right: 'AST'
+# #     type: Optional[SimType] = None
+
+# @dataclass
+# class IfElse:
+#     condition: 'AST'
+#     iftrue: 'AST'
+#     iffalse: 'AST'
+# #     type: Optional[SimType] = None
+
+# AST = NumLiteral | BoolLiteral | BinOp | IfElse
+
+@dataclass
+class TypeError(Exception):
+    pass
+
+# Since we don't have variables, environment is not needed.
+def typecheck(program: AST, env = None):
+    match program:
+        case NumLiteral() as t: # already typed.
+            return t
+        case BoolLiteral() as t: # already typed.
+            return t
+        case BinOp(op, left, right) if op in ["+", "*"]:
+            tleft = typecheck(left)
+            tright = typecheck(right)
+
+            print(isinstance(tleft, NumLiteral), isinstance(tright, NumLiteral))
+            if isinstance(tleft, NumLiteral) != True or isinstance(tright, NumLiteral) != True:
+                raise TypeError()
+            return NumLiteral();
+        
+        
+#         case BinOp("<", left, right):
+#             tleft = typecheck(left)
+#             tright = typecheck(right)
+#             if tleft.type != NumType() or tright.type != NumType():
+#                 raise TypeError()
+#             return BinOp("<", left, right, BoolType())
+#         case BinOp("=", left, right):
+#             tleft = typecheck(left)
+#             tright = typecheck(right)
+#             if tleft.type != tright.type:
+#                 raise TypeError()
+#             return BinOp("=", left, right, BoolType())
+#         case IfElse(c, t, f): # We have to typecheck both branches.
+#             tc = typecheck(c)
+#             if tc.type != BoolType():
+#                 raise TypeError()
+#             tt = typecheck(t)
+#             tf = typecheck(f)
+#             if tt.type != tf.type: # Both branches must have the same type.
+#                 raise TypeError()
+#             return IfElse(tc, tt, tf, tt.type) # The common type becomes the type of the if-else.
+        case _:
+             raise TypeError()
+
+def test_typecheck():
+#     import pytest
+    typecheck(BinOp("+", NumLiteral(2), BoolLiteral(False)))
+#     assert te.type == NumType()
+#     te = typecheck(BinOp("<", NumLiteral(2), NumLiteral(3)))
+#     assert te.type == BoolType()
+#     with pytest.raises(TypeError):
+#         typecheck(BinOp("+", BinOp("*", NumLiteral(2), NumLiteral(3)), BinOp("<", NumLiteral(2), NumLiteral(3))))
+        
+# test_typecheck()

unresolved_tree

@@ -0,0 +1,5 @@
+Unresolved Tree:
+Seq(statements=[Statement(command='print',
+                          statement=BinOp(operator='+',
+                                          left=NumLiteral(value=Fraction(3, 1)),
+                                          right=NumLiteral(value=Fraction(4, 1))))])