Merge pull request #6 from CanTheCoderBoi/dev

Logical Operators!

README.md

@@ -13,5 +13,6 @@ ama ciddi bir hata varsa `Issues` kısmında bildirebilirsiniz.
 - [X] Yazdırma ve Okuma
 - [X] Basit Döngü
 - [X] Eğer
-- [ ] Mantıksal İşlemler
+- [X] Mantıksal İşlemler
 - [ ] Fonksiyonlar
+- [ ] Eksili Sayılar

src/lexer.py

@@ -15,9 +15,15 @@ def __init__(self):
         self.lg.add("IF", r"ise")
         self.lg.add("ELSE", r"değil")
 
-        self.lg.add("=", r"=")
+        self.lg.add("==", r"==")
+        self.lg.add("!=", r"!=")
+        self.lg.add("<=", r"<=")
+        self.lg.add(">=", r">=")
+        self.lg.add(">", r">")
+        self.lg.add("<", r"<")
         self.lg.add("+=", r"\+=")
         self.lg.add("-=", r"\-=")
+        self.lg.add("=", r"=")
 
         self.lg.add("STRING", r"'.*'")
         self.lg.add("FLOAT",  r"\d+(\.\d+)") #r"[-]?\d+(\.\d+)"

src/mer_ast.py

@@ -4,48 +4,50 @@
 class Statements:
     def __init__(self, nodes):
         self.nodes = nodes
-    
+
     def eval(self):
         for node in self.nodes:
             node.eval()
 
 class Boolean:
     def __init__(self, value):
-        self.value = value.getstr()
+        self.value = value
 
     def eval(self):
-        if (self.value == "doğru"):
-            return True
-        elif (self.value == "yanlış"):
-            return False
+        if (self.value):
+            return "doğru"
+        else:
+            return "yanlış"
 
 
 class Integer:
     def __init__(self, value):
-        self.value = value.getstr()
+        self.value = value
 
     def eval(self):
         return int(self.value)
 
 
 class Float:
     def __init__(self, value):
-        self.value = value.getstr()
+        self.value = value
 
     def eval(self):
         return float(self.value)
 
 
 class String:
     def __init__(self, value):
-        self.value = value.getstr()
+        self.value = value
 
     def eval(self):
         return str(self.value[1:-1])
 
+
 class Null:
     def eval(self):
         return self
+
     def getstr(self):
         return 'yok'
 
@@ -67,17 +69,30 @@ def eval(self):
             return self.left.eval() / self.right.eval()
         elif self.binop == "MOD":
             return self.left.eval() % self.right.eval()
+        elif self.binop == "==":
+            return Boolean(self.left.eval() == self.right.eval()).eval()
+        elif self.binop == "!=":
+            return Boolean(self.left.eval() != self.right.eval()).eval()
+        elif self.binop == ">":
+            return Boolean(self.left.eval() > self.right.eval()).eval()
+        elif self.binop == "<":
+            return Boolean(self.left.eval() < self.right.eval()).eval()
+        elif self.binop == ">=":
+            return Boolean(self.left.eval() >= self.right.eval()).eval()
+        elif self.binop == "<=":
+            return Boolean(self.left.eval() <= self.right.eval()).eval()
         else:
             raise AssertionError("Something went super wrong.")
 
+
 class If:
     def __init__(self, condition, body, else_body=None):
         self.condition = condition
         self.body = body
         self.else_body = else_body
 
     def eval(self):
-        if self.condition.eval():
+        if self.condition.eval() == "doğru":
             return self.body.eval()
         elif self.else_body is not None:
             return self.else_body.eval()
@@ -91,6 +106,7 @@ def __init__(self, value):
     def eval(self):
         print(self.value.eval())
 
+
 class Read:
     def __init__(self, question):
         self.question = question
@@ -99,10 +115,11 @@ def eval(self):
         value = input(self.question.eval())
         if value.isnumeric():
             if '.' not in value:
-                return Integer(value)
+                return int(value)
             else:
-                return Float(value)
-        return value
+                return float(value)
+        return str(value)
+
 
 class Loop:
     def __init__(self, time, function):
@@ -120,15 +137,15 @@ def __init__(self, name, value):
         self.value = value
 
     def eval(self):
-        variables[self.name.getstr()] = self.value.eval()
+        variables[self.name] = self.value.eval()
 
 
 class Variable:
     def __init__(self, name):
         self.name = name
 
     def eval(self):
-        if self.name.getstr() in variables.keys():
-            return variables[self.name.getstr()]
+        if self.name in variables.keys():
+            return variables[self.name]
         else:
             raise RuntimeError("Not Declared:", self.name)

src/parser.py

@@ -3,6 +3,7 @@
 from src.mer_ast import *
 import warnings
 
+
 class Parser:
 
     def __init__(self):
@@ -12,10 +13,13 @@ def __init__(self):
              'MUL', 'MOD', '(', ')', ',',
              'LOOP', 'BOOLEAN', 'IDENTIFIER',
              '=', '+=', '-=', '{', '}', 'IF',
-             'ELSE', 'READ'
-            ],
+             'ELSE', 'READ', '==', '!=', '>',
+             '<', '>=', '<='
+             ],
             precedence=[
                 ('left', ['INTEGER', 'FLOAT']),
+                ("left", ["IF", "LOOP", "ELSE"]),
+                ('left', ["<=", ">=", "==", "="]),
                 ('left', ['ADD', 'SUB']),
                 ('left', ['MUL', 'DIV'])
             ]
@@ -39,17 +43,41 @@ def reading(p):
         def loop(p):
             return Loop(p[2], p[4])
 
+        @self.pg.production('expression : expression == expression')
+        def equals(p):
+            return BinOp(p[0], "==", p[2])
+
+        @self.pg.production('expression : expression != expression')
+        def not_equals(p):
+            return BinOp(p[0], "!=", p[2])
+
+        @self.pg.production('expression : expression < expression')
+        def smaller(p):
+            return BinOp(p[0], "<", p[2])
+
+        @self.pg.production('expression : expression > expression')
+        def bigger(p):
+            return BinOp(p[0], ">", p[2])
+
+        @self.pg.production('expression : expression >= expression')
+        def big_equals(p):
+            return BinOp(p[0], ">=", p[2])
+
+        @self.pg.production('expression : expression <= expression')
+        def small_equals(p):
+            return BinOp(p[0], "<=", p[2])
+
         @self.pg.production('statement : IDENTIFIER = expression')
         def variable(p):
-            return Assign(p[0], p[2])
+            return Assign(p[0].getstr(), p[2])
 
         @self.pg.production('statement : IDENTIFIER += expression')
         def plus_equals(p):
-            return Assign(p[0], BinOp(Variable(p[0]), "ADD", p[2]))
+            return Assign(p[0].getstr(), BinOp(Variable(p[0].getstr()), "ADD", p[2]))
 
         @self.pg.production('statement : IDENTIFIER -= expression')
-        def plus_equals(p):
-            return Assign(p[0], BinOp(Variable(p[0]), "SUB", p[2]))
+        def minus_equals(p):
+            return Assign(p[0].getstr(), BinOp(Variable(p[0].getstr()), "SUB", p[2]))
 
         @self.pg.production('block : { statements }')
         @self.pg.production('block : { }')
@@ -84,24 +112,27 @@ def exp_parens(p):
 
         @self.pg.production('expression : INTEGER')
         def exp_number(p):
-            return Integer(p[0])
-        
+            return Integer(p[0].getstr())
+
         @self.pg.production('expression : FLOAT')
         def exp_float(p):
-            return Float(p[0])
-        
+            return Float(p[0].getstr())
+
         @self.pg.production('expression : STRING')
         def exp_string(p):
-            return String(p[0])
+            return String(p[0].getstr())
 
         @self.pg.production('expression : BOOLEAN')
         def exp_boolean(p):
-            return Boolean(p[0])
+            if p[0].getstr() == "doğru":
+                return Boolean(True)
+            else:
+                return Boolean(False)
 
         @self.pg.production('expression : IDENTIFIER')
         def call(p):
-            return Variable(p[0])
-        
+            return Variable(p[0].getstr())
+
         @self.pg.error
         def error_handler(token):
             raise ValueError(f"Ran into a {token} where it was not expected")

tests.mer

@@ -1,13 +1,13 @@
 a = 0
-
+b = 10
 tekrar(10) {
     a+=1
     yazdır(a)
 }
 // Output: 10
 
-doğru ise {
-    yazdır('doğru')
+b >= a ise {
+    yazdır(doğru)
 } değil {
-    yazdır('yanlış')
+    yazdır(yanlış)
 }