Merge pull request #8

v10.0 : handle variable not defined error

Author: amazingcoderpro

README.md

@@ -55,4 +55,7 @@ python interpreter.py assignments.txt
 
 ```shell
 python genastdot.py assignments.txt > ast.dot && dot -Tpng -o ast_v9.png ast.dot  
-```
+```
+
+### v10.0
+增加符号表记录变量的定义，以处理使用未处理的变量

assignments.txt

@@ -1,5 +1,5 @@
-a=1
+a=1.34
 b=2
 c=a+b
 d=a+b-c
-e=45+d
+e=45+f

func_test.py

@@ -7,7 +7,7 @@
 @date: 2024/8/29
 @desc: 
 """
-from sip_token import Token
+from spi_token import Token
 from abs_syntax_tree import Num, BinOp, UnaryOp
 from interpreter import Analyzer, Parser, Interpreter, INTEGER, MINUS
 
@@ -31,7 +31,7 @@ def test_analyzer():
     print(text)
     analyzer = Analyzer(text)
     token = analyzer.get_next_token()
-    while token.type != 'EOF':
+    while token.symbol_type != 'EOF':
         print(token)
         token = analyzer.get_next_token()
 

genptdot.py

@@ -59,7 +59,7 @@ def eat(self, token_type):
         # type and if they match then "eat" the current token
         # and assign the next token to the self.current_token,
         # otherwise raise an exception.
-        if self.current_token.type == token_type:
+        if self.current_token.symbol_type == token_type:
             self.current_node.add(TokenNode(self.current_token.value))
             self.current_token = self.lexer.get_next_token()
         else:
@@ -73,9 +73,9 @@ def factor(self):
         self.current_node = node
 
         token = self.current_token
-        if token.type == INTEGER:
+        if token.symbol_type == INTEGER:
             self.eat(INTEGER)
-        elif token.type == LPAREN:
+        elif token.symbol_type == LPAREN:
             self.eat(LPAREN)
             self.expr()
             self.eat(RPAREN)
@@ -91,11 +91,11 @@ def term(self):
 
         self.factor()
 
-        while self.current_token.type in (MUL, DIV):
+        while self.current_token.symbol_type in (MUL, DIV):
             token = self.current_token
-            if token.type == MUL:
+            if token.symbol_type == MUL:
                 self.eat(MUL)
-            elif token.type == DIV:
+            elif token.symbol_type == DIV:
                 self.eat(DIV)
 
             self.factor()
@@ -119,11 +119,11 @@ def expr(self):
 
         self.term()
 
-        while self.current_token.type in (PLUS, MINUS):
+        while self.current_token.symbol_type in (PLUS, MINUS):
             token = self.current_token
-            if token.type == PLUS:
+            if token.symbol_type == PLUS:
                 self.eat(PLUS)
-            elif token.type == MINUS:
+            elif token.symbol_type == MINUS:
                 self.eat(MINUS)
 
             self.term()

interpreter.py

@@ -15,14 +15,16 @@
 v7.0 : using ASTs represent the operator-operand model of arithmetic expressions.
 v8.0 : support unary operators (+, -)
 v9.0 : support to handle python assignment statements.
+v10.0 : handle variable not defined error
 """
 
 import keyword
 from abs_syntax_tree import BinOp, Num, UnaryOp, Var, NoOp, Compound, Assign
-from sip_token import Token
+from spi_token import Token
+from spi_symbol import VarSymbol, SymbolTable
 
 
-INTEGER, PLUS, EOF, MINUS, MUL, DIV, LPAREN, RPAREN, ID, ASSIGN, REPL = 'INTEGER', 'PLUS', 'EOF', 'MINUS', 'MUL', 'DIV', 'LPAREN', 'RPAREN', 'ID', 'ASSIGN', 'REPL'
+INTEGER, FLOAT, PLUS, EOF, MINUS, MUL, DIV, LPAREN, RPAREN, ID, ASSIGN, REPL = 'INTEGER', 'FLOAT', 'PLUS', 'EOF', 'MINUS', 'MUL', 'DIV', 'LPAREN', 'RPAREN', 'ID', 'ASSIGN', 'REPL'
 PYTHON_RESERVED_KEYWORDS = {key: Token(key, key) for key in keyword.kwlist}
 
 class Analyzer(object):
@@ -55,13 +57,21 @@ def peek(self):
         else:
             return self.text[peek_pos]
 
-    def integer(self):
+    def number(self):
         """return a multi-digit integer"""
         result = ''
         while self.current_char is not None and self.current_char.isdigit():
             result += self.current_char
             self.advance()
-        return int(result)
+        if self.current_char == '.':
+            result += self.current_char
+            self.advance()
+            while self.current_char is not None and self.current_char.isdigit():
+                result += self.current_char
+                self.advance()
+            return float(result)
+        else:
+            return int(result)
 
     def identifier(self):
         """return a multi-digit identifier"""
@@ -81,7 +91,8 @@ def get_next_token(self):
                 self.skip_whitespace()
                 continue
             if self.current_char.isdigit():
-                return Token(INTEGER, self.integer())
+                number = self.number()
+                return Token(INTEGER, number) if isinstance(number, int) else Token(FLOAT, number)
             if self.current_char == '+':
                 self.advance()
                 return Token(PLUS, '+')
@@ -228,6 +239,9 @@ def factor(self):
         elif self.current_token.type == INTEGER:
             self.eat(INTEGER)
             return Num(token)
+        elif self.current_token.type == FLOAT:
+            self.eat(FLOAT)
+            return Num(token)
         elif self.current_token.type == LPAREN:
             self.eat(LPAREN)
             node = self.expr()
@@ -317,12 +331,75 @@ def visit(self, node):
 
     def interpret(self):
         tree = self.parser.parse()
+        symbol_builder = SymbolTableBuilder()
+        symbol_builder.visit(tree)
         return self.visit(tree)
 
 
+class SymbolTableBuilder(NodeVisitor):
+    def __init__(self):
+        self.symtab = SymbolTable()
+
+    def visit_BinOp(self, node):
+        self.visit(node.left)
+        self.visit(node.right)
+
+    def visit_Num(self, node):
+        pass
+
+    def visit_UnaryOp(self, node):
+        self.visit(node.expr)
+
+    def visit_Compound(self, node):
+        for child in node.children:
+            self.visit(child)
+
+    def visit_NoOp(self, node):
+        pass
+
+    def visit_VarDecl(self, node):
+        type_name = node.type_node.value
+        type_symbol = self.symtab.lookup(type_name)
+        var_name = node.var_node.value
+        var_symbol = VarSymbol(var_name, type_symbol)
+        self.symtab.define(var_symbol)
+
+    def visit_Assign(self, node):
+        # python代码中赋值就是定义，没有声明
+        var_name = node.left.value
+        var_symbol = VarSymbol(var_name, None)
+        self.symtab.define(var_symbol)
+        self.visit(node.right)
+
+    def visit_Var(self, node):
+        var_name = node.value
+        var_symbol = self.symtab.lookup(var_name)
+        if var_symbol is None:
+            raise NameError(repr(var_name))
+
+    def visit(self, node):
+        if isinstance(node, BinOp):
+            return self.visit_BinOp(node)
+        elif isinstance(node, Num):
+            return self.visit_Num(node)
+        elif isinstance(node, UnaryOp):
+            return self.visit_UnaryOp(node)
+        elif isinstance(node, Var):
+            return self.visit_Var(node)
+        elif isinstance(node, Assign):
+            return self.visit_Assign(node)
+        elif isinstance(node, Compound):
+            return self.visit_Compound(node)
+        elif isinstance(node, NoOp):
+            return self.visit_NoOp(node)
+
+
+
 def main():
     import sys
-    text = open(sys.argv[1], 'r').read()
+    py_file = sys.argv[1]
+    # py_file = 'assignments.txt'
+    text = open(py_file, 'r').read()
     print(f"begin parse input: {text}")
     lexer = Analyzer(text)
     parser = Parser(lexer)

spi_symbol.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+@file: spi_symbol.py
+@author: amazing coder
+@date: 2024/8/31
+@desc: 增加通用符号类
+"""
+
+class Symbol(object):
+    def __int__(self, name, type=None):
+        self.name = name
+        self.symbol_type = type
+
+
+class BuiltinTypeSymbol(Symbol):
+    def __init__(self, name):
+        super().__int__(self, name)
+
+    def __str__(self):
+        return self.name
+
+    __repr__ = __str__
+
+
+class VarSymbol(Symbol):
+    def __init__(self, name, type=None):
+        # python 定义时可以不指定类型
+        super().__int__(name, type)
+
+    def __str__(self):
+        return f'VarSymbol:name={self.name}: type={str(self.symbol_type)}'
+
+    __repr__ = __str__
+
+
+class SymbolTable(object):
+    def __init__(self):
+        self._symbols = {}
+
+    def __str__(self):
+        return 'Symbols: {symbols}'.format(symbols=[value for value in self._symbols.values()])
+
+    __repr__ = __str__
+
+    def define(self, symbol):
+        print('Define: %s' % symbol)
+        self._symbols[symbol.name] = symbol
+        return symbol
+
+    def lookup(self, name):
+        print('Lookup: %s' % name)
+        symbol = self._symbols.get(name)
+        return symbol
+
+
+def test_class():
+    int_type = BuiltinTypeSymbol('INTEGER')
+    float_type = BuiltinTypeSymbol('FLOAT')
+    var_x = VarSymbol('x', int_type)
+    var_y = VarSymbol('y', float_type)
+    print(var_x)
+    print(var_y)
+
+
+if __name__ == '__main__':
+    test_class()

sip_token.py renamed to spi_token.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 
 """
-@file: sip_token.py
+@file: spi_token.py
 @author: amazing coder
 @date: 2024/8/29
 @desc: