【編譯原理】讓我們來構建一個簡單的解釋器（Let’s Build A Simple Interpreter. Part 9.）

文章目錄

• • spi.py
  • spi_lexer

我記得當我在大學（很久以前）學習系統編程時，我相信唯一“真正”的語言是匯編和 C。而 Pascal 是——怎么說好一點——一種非常高級的語言不想知道幕后發生了什么的應用程序開發人員。

那時我幾乎不知道我會用 Python 編寫幾乎所有東西（并且喜歡它的每一點）來支付我的賬單，而且我還會因為我在第一篇文章中提到的原因為 Pascal 編寫解釋器和編譯器該系列的。

這些天，我認為自己是一個編程語言愛好者，我對所有語言及其獨特的功能都很著迷。話雖如此，我必須指出，我比其他語言更喜歡使用某些語言。我有偏見，我將是第一個承認這一點的人。😃

這是我之前：


好的，讓我們進入正題。以下是您今天要學習的內容：

如何解析和解釋 Pascal 程序定義。
1、如何解析和解釋復合語句（compound statements）。
2、如何解析和解釋賦值語句（assignment statements），包括變量（variables）。
3、關于符號表（symbol tables）以及如何存儲和查找變量的一些知識。

我將使用以下示例 Pascal-like 程序來介紹新概念：

BEGINBEGINnumber := 2;a := number;b := 10 * a + 10 * number / 4;c := a - - bEND;x := 11; END.

您可以說，按照本系列的前幾篇文章，到目前為止您編寫的命令行解釋器是一個很大的跳躍，但我希望這種跳躍會帶來興奮。它不再“只是”一個計算器，我們在這里變得認真了，Pascal 是認真的。😃

讓我們深入了解新語言結構的語法圖（syntax diagrams）及其相應的語法規則（grammar rules）。

在你的標記上：準備好了。放。出發！

1、我將從描述什么是 Pascal程序開始。Pascal程序由一個以點結尾的復合語句組成。下面是一個程序示例：

“BEGIN END.”

我必須提示，這不是一個完整的程序定義，我們將在本系列的后面對其進行擴展。

2、什么是復合語句？復合語句（compound statement）是標有塊BEGIN和END 語句包括其它復合語句，它可以包含一個列表（list）（可能為空）。復合語句中的每一條語句，除了最后一條，都必須以分號（semicolon）結束。塊中的最后一條語句可能有也可能沒有終止分號。以下是一些有效復合語句的示例：

“BEGIN END” “BEGIN a := 5; x := 11 END” “BEGIN a := 5; x := 11; END” “BEGIN BEGIN a := 5 END; x := 11 END”

3、語句列表（statement list ）是一個復合語句中的零條或多個語句的列表。有關一些示例，請參見上文。

4、語句可以是一個復合語句，一個賦值語句，或者它可以是一個空的 語句。

5、賦值語句（assignment statement）是一個變量后面跟著個ASSIGN標記（兩個字符，“：”和“=”），后面再跟著個表達式。

“a := 11” “b := a + 9 - 5 * 2”

6、變量是一個標識符。我們為變量使用ID標記。標記的值將是變量的名稱，如“a”、“number”等。在以下代碼塊中，‘a’ 和 ‘b’ 是變量：

“BEGIN a := 11; b := a + 9 - 5 * 2 END”

7、一個空的聲明表示，沒有進一步的生成語法規則。我們使用empty_statement語法規則來指示 解析器中statement_list的結尾，并允許像“ BEGIN END ”中那樣的空復合語句。

8、factor規則被用來更新處理變量。

現在讓我們來看看我們完整的語法：

program : compound_statement DOTcompound_statement : BEGIN statement_list ENDstatement_list : statement| statement SEMI statement_liststatement : compound_statement| assignment_statement| emptyassignment_statement : variable ASSIGN exprempty :expr: term ((PLUS | MINUS) term)*term: factor ((MUL | DIV) factor)*factor : PLUS factor| MINUS factor| INTEGER| LPAREN expr RPAREN| variablevariable: ID

您可能已經注意到，我沒有在復合語句規則中使用星號“*” 來表示零次或多次重復，而是明確指定了statement_list規則。這是表示“零或多個”操作的另一種方式，當我們查看本系列后面的PLY等解析器生成器時，它會派上用場。我還將“( PLUS | MINUS ) factor ”子規則拆分為兩個單獨的規則。

為了支持更新的語法，我們需要對詞法分析器、解析器和解釋器進行一些更改。讓我們一一回顧這些變化。

以下是詞法分析器更改的摘要：

1、為了支持 Pascal 程序的定義、復合語句、賦值語句和變量，我們的詞法分析器需要返回新的標記：

• BEGIN（標記復合語句的開始）
• END（標記復合語句的結束）
• DOT（Pascal 程序定義所需的點字符“.”的標記）
• ASSIGN（兩個字符序列“:=”的標記）。在 Pascal 中，賦值運算符與 C、Python、Java、Rust 或 Go 等許多其他語言不同，在這些語言中，您可以使用單個字符“=”來表示賦值
• SEMI（分號字符“;”的標記，用于標記復合語句內的語句結束）
• ID（有效標識符的標記。標識符以字母字符開頭，后跟任意數量的字母數字字符）

2、有時，為了能夠區分以相同字符開頭的不同標記，（':' vs ':=' or '==' vs '=>' ）我們需要查看輸入緩沖區而不實際消耗下一個字符。出于這個特殊目的，我引入了一個peek 方法，它將幫助我們標記賦值語句。該方法不是嚴格要求的，但我想我會在本系列的前面介紹它，它也會使get_next_token 方法更簡潔一些。它所做的只是從文本緩沖區返回下一個字符，而不增加self.pos變量。這是方法本身：

def peek(self):peek_pos = self.pos + 1if peek_pos > len(self.text) - 1:return Noneelse:return self.text[peek_pos]

3、因為 Pascal 變量和保留關鍵字都是標識符，所以我們將它們的處理合并到一個稱為_id 的方法中。它的工作方式是詞法分析器使用一系列字母數字字符，然后檢查該字符序列是否為保留字（reserved word）。如果是，則為該保留關鍵字返回一個預先構造的標記。如果它不是保留關鍵字，則返回一個新的ID令牌，其值為字符串（詞素【lexeme】）。我打賭此時你會想，“天哪，給我看看代碼。” ：） 這里是：

RESERVED_KEYWORDS = {'BEGIN': Token('BEGIN', 'BEGIN'),'END': Token('END', 'END'), }def _id(self):"""Handle identifiers（標識符） and reserved keywords"""result = ''while self.current_char is not None and self.current_char.isalnum():result += self.current_charself.advance()token = RESERVED_KEYWORDS.get(result, Token(ID, result))return token

現在讓我們看看主詞法分析器方法get_next_token的變化：

def get_next_token(self):while self.current_char is not None:...if self.current_char.isalpha():return self._id()if self.current_char == ':' and self.peek() == '=':self.advance()self.advance()return Token(ASSIGN, ':=')if self.current_char == ';':self.advance()return Token(SEMI, ';')if self.current_char == '.':self.advance()return Token(DOT, '.')...

是時候看看我們閃亮的新詞法分析器的所有榮耀和動作了。從GitHub下載源代碼并從保存spi.py 文件的同一目錄啟動 Python shell ：（spi.py代碼見文章目錄）也可直接見spi_lexer代碼，在pycharm中可直接運行或調試看到結果

>>> from spi import Lexer >>> lexer = Lexer('BEGIN a := 2; END.') >>> lexer.get_next_token() Token(BEGIN, 'BEGIN') >>> lexer.get_next_token() Token(ID, 'a') >>> lexer.get_next_token() Token(ASSIGN, ':=') >>> lexer.get_next_token() Token(INTEGER, 2) >>> lexer.get_next_token() Token(SEMI, ';') >>> lexer.get_next_token() Token(END, 'END') >>> lexer.get_next_token() Token(DOT, '.') >>> lexer.get_next_token() Token(EOF, None) >>>

繼續解析器更改。

以下是我們的解析器更改的摘要：

讓我們從新的AST 節點開始：

復合 AST節點表示復合語句。它在其children 變量中包含一個語句節點列表。

class Compound(AST):"""Represents a 'BEGIN ... END' block"""def __init__(self):self.children = []

Assign AST節點代表一個賦值語句。它的左變量用于存儲一個Var節點，它的右變量用于存儲由 expr 解析器方法返回的節點：

class Assign(AST):def __init__(self, left, op, right):self.left = leftself.token = self.op = opself.right = right

Var AST節點（你猜對了）代表一個變量。該self.value持有變量的名稱。

class Var(AST):"""The Var node is constructed out of ID token."""def __init__(self, token):self.token = tokenself.value = token.value

NoOp節點用于表示空語句。例如，’ BEGIN END ’ 是一個沒有語句的有效復合語句。

class NoOp(AST):pass

您還記得，語法中的每個規則在我們的遞歸下降解析器中都有一個對應的方法。這次我們添加了七個新方法。這些方法負責解析新的語言結構和構建新的AST節點。它們非常簡單：（ps. 我就喜歡作者這么說！）

def program(self):"""program : compound_statement DOT"""node = self.compound_statement()self.eat(DOT)return nodedef compound_statement(self):"""compound_statement: BEGIN statement_list END"""self.eat(BEGIN)nodes = self.statement_list()self.eat(END)root = Compound()for node in nodes:root.children.append(node)return rootdef statement_list(self):"""statement_list : statement| statement SEMI statement_list"""node = self.statement()results = [node]while self.current_token.type == SEMI:self.eat(SEMI)results.append(self.statement())if self.current_token.type == ID:self.error()return resultsdef statement(self):"""statement : compound_statement| assignment_statement| empty"""if self.current_token.type == BEGIN:node = self.compound_statement()elif self.current_token.type == ID:node = self.assignment_statement()else:node = self.empty()return nodedef assignment_statement(self):"""assignment_statement : variable ASSIGN expr"""left = self.variable()token = self.current_tokenself.eat(ASSIGN)right = self.expr()node = Assign(left, token, right)return nodedef variable(self):"""variable : ID"""node = Var(self.current_token)self.eat(ID)return nodedef empty(self):"""An empty production"""return NoOp()

我們還需要更新現有的factor方法來解析變量：

def factor(self):"""factor : PLUS factor| MINUS factor| INTEGER| LPAREN expr RPAREN| variable"""token = self.current_tokenif token.type == PLUS:self.eat(PLUS)node = UnaryOp(token, self.factor())return node...else:node = self.variable()return node

解析器的parse方法更新為通過解析程序定義來啟動解析過程：

def parse(self):node = self.program()if self.current_token.type != EOF:self.error()return node

這是我們的示例程序：

BEGINBEGINnumber := 2;a := number;b := 10 * a + 10 * number / 4;c := a - - bEND;x := 11; END.

讓我們用genastdot.py對其進行可視化（為簡潔起見，當顯示Var節點時，它只顯示節點的變量名稱，當顯示一個 Assign 節點時，它顯示 ‘:=’ 而不是顯示 ‘Assign’ 文本）：

$ python genastdot.py assignments.txt > ast.dot && dot -Tpng -o ast.png ast.dot

最后，這里是所需的解釋器更改：

要解釋新的AST節點，我們需要向解釋器添加相應的訪問者方法。有四種新的訪問者方法：

訪問_Compound
訪問_分配
訪問_變量
訪問_NoOp

Compound和NoOp訪問者方法非常簡單。該visit_Compound方法遍歷它的孩子和參觀各一轉，和visit_NoOp方法不起作用。

def visit_Compound(self, node):for child in node.children:self.visit(child)def visit_NoOp(self, node):pass

在分配和瓦爾游客方法值得仔細研究。

當我們為變量賦值時，我們需要將該值存儲在某個地方以備日后需要時使用，這正是visit_Assign方法所做的：

def visit_Assign(self, node):var_name = node.left.valueself.GLOBAL_SCOPE[var_name] = self.visit(node.right)

該方法在符號表GLOBAL_SCOPE 中存儲鍵值對（變量名和與變量關聯的值）。什么是符號表？甲符號表是一個抽象數據類型（ADT用于在源代碼中追蹤各種符號）。我們現在唯一的符號類別是變量，我們使用 Python 字典來實現符號表ADT。現在我只想說，本文中符號表的使用方式非常“hacky”：它不是一個具有特殊方法的單獨類，而是一個簡單的 Python 字典，它還作為內存空間執行雙重任務。在以后的文章中，我將更詳細地討論符號表，我們還將一起刪除所有的黑客。

讓我們看一下語句“a := 3;”的AST 和visit_Assign方法之前和之后的符號表完成它的工作：

現在讓我們看一下語句“b := a + 7;”的AST

如您所見，賦值語句的右側 - “a + 7” - 引用了變量 ‘a’，因此在我們評估表達式“a + 7”之前，我們需要找出 ’ 的值a’ 是，這是visit_Var 方法的職責：

def visit_Var(self, node):var_name = node.valueval = self.GLOBAL_SCOPE.get(var_name)if val is None:raise NameError(repr(var_name))else:return val

當該方法訪問上圖AST 中的Var節點時，它首先獲取變量的名稱，然后使用該名稱作為GLOBAL_SCOPE字典中的鍵來獲取變量的值。如果它可以找到該值，則返回該值，否則會引發NameError異常。以下是在評估賦值語句“b := a + 7;”之前的符號表內容：

這些都是我們今天需要做的改變，以使我們的解釋器打勾。在主程序結束時，我們簡單地將符號表 GLOBAL_SCOPE 的內容打印到標準輸出。

讓我們從 Python 交互式 shell 和命令行中使用我們更新的解釋器作為驅動器。確保在測試之前下載了解釋器的源代碼和assignments.txt文件：

啟動你的 Python shell：

$ python >>> from spi import Lexer, Parser, Interpreter >>> text = """\ ... BEGIN ... ... BEGIN ... number := 2; ... a := number; ... b := 10 * a + 10 * number / 4; ... c := a - - b ... END; ... ... x := 11; ... END. ... """ >>> lexer = Lexer(text) >>> parser = Parser(lexer) >>> interpreter = Interpreter(parser) >>> interpreter.interpret() >>> print(interpreter.GLOBAL_SCOPE) {'a': 2, 'x': 11, 'c': 27, 'b': 25, 'number': 2}

從命令行，使用源文件作為我們解釋器的輸入：

$ python spi.py assignments.txt {'a': 2, 'x': 11, 'c': 27, 'b': 25, 'number': 2}

如果您還沒有嘗試過，現在就嘗試一下，親眼看看解釋器是否正確地完成了它的工作。

讓我們總結一下你在這篇文章中擴展 Pascal 解釋器需要做的事情：

向語法添加新規則
向詞法分析器添加新標記和支持方法并更新get_next_token 方法
向解析器添加新的AST節點以獲得新的語言結構
將與新語法規則相對應的新方法添加到我們的遞歸下降解析器中，并在必要時更新任何現有方法（因子方法，我在看著你。😃
向解釋器添加新的訪問者方法
添加用于存儲變量和查找變量的字典

在這一部分中，我不得不介紹一些“技巧”，我們將隨著系列的推進而將其刪除：

該程序的語法規則是不完整的。稍后我們將使用其他元素對其進行擴展。
Pascal 是一種靜態類型語言，您必須在使用它之前聲明一個變量及其類型。但是，正如您所看到的，本文中的情況并非如此。
到目前為止沒有類型檢查。在這一點上這沒什么大不了的，但我只是想明確地提到它。例如，一旦我們向解釋器添加更多類型，當您嘗試添加字符串和整數時，我們將需要報告錯誤。
這部分中的符號表是一個簡單的 Python 字典，它具有雙重存儲空間的功能。不用擔心：符號表是一個非常重要的主題，我將專門針對它們撰寫幾篇文章。內存空間（運行時管理）本身就是一個話題。
在我們之前文章中的簡單計算器中，我們使用正斜杠字符“/”來表示整數除法。但是，在 Pascal 中，您必須使用關鍵字div來指定整數除法（參見練習 1）。
我還特意引入了一個 hack，以便您可以在練習 2 中修復它：在 Pascal 中，所有保留關鍵字和標識符都不區分大小寫，但本文中的解釋器將它們視為區分大小寫。

為了讓你保持健康，這里有新的練習給你：

Pascal 變量和保留關鍵字不區分大小寫，這與許多其他編程語言不同，因此BEGIN、begin和BeGin它們都引用相同的保留關鍵字。更新解釋器，使變量和保留關鍵字不區分大小寫。使用以下程序對其進行測試：

BEGINBEGINnumber := 2;a := NumBer;B := 10 * a + 10 * NUMBER / 4;c := a - - bend;x := 11; END.

我之前在“hacks”部分提到我們的解釋器使用正斜杠字符“/”來表示整數除法，但它應該使用 Pascal 的保留關鍵字div進行整數除法。更新解釋器以使用div關鍵字進行整數除法，從而消除其中一種技巧。

更新解釋器，以便變量也可以以下劃線開頭，如 ‘_num := 5’。

spi.py

""" SPI - Simple Pascal Interpreter. Part 9."""############################################################################### # # # LEXER # # # ################################################################################ Token types # # EOF (end-of-file) token is used to indicate that # there is no more input left for lexical analysis (INTEGER, PLUS, MINUS, MUL, DIV, LPAREN, RPAREN, ID, ASSIGN,BEGIN, END, SEMI, DOT, EOF) = ('INTEGER', 'PLUS', 'MINUS', 'MUL', 'DIV', '(', ')', 'ID', 'ASSIGN','BEGIN', 'END', 'SEMI', 'DOT', 'EOF' )class Token(object):def __init__(self, type, value):self.type = typeself.value = valuedef __str__(self):"""String representation of the class instance.Examples:Token(INTEGER, 3)Token(PLUS, '+')Token(MUL, '*')"""return 'Token({type}, {value})'.format(type=self.type,value=repr(self.value))def __repr__(self):return self.__str__()RESERVED_KEYWORDS = {'BEGIN': Token('BEGIN', 'BEGIN'),'END': Token('END', 'END'), }class Lexer(object):def __init__(self, text):# client string input, e.g. "4 + 2 * 3 - 6 / 2"self.text = text# self.pos is an index into self.textself.pos = 0self.current_char = self.text[self.pos]def error(self):raise Exception('Invalid character')def advance(self):"""Advance the `pos` pointer and set the `current_char` variable."""self.pos += 1if self.pos > len(self.text) - 1:self.current_char = None # Indicates end of inputelse:self.current_char = self.text[self.pos]def peek(self):peek_pos = self.pos + 1if peek_pos > len(self.text) - 1:return Noneelse:return self.text[peek_pos]def skip_whitespace(self):while self.current_char is not None and self.current_char.isspace():self.advance()def integer(self):"""Return a (multidigit) integer consumed from the input."""result = ''while self.current_char is not None and self.current_char.isdigit():result += self.current_charself.advance()return int(result)def _id(self):"""Handle identifiers and reserved keywords"""result = ''while self.current_char is not None and self.current_char.isalnum():result += self.current_charself.advance()token = RESERVED_KEYWORDS.get(result, Token(ID, result))return tokendef get_next_token(self):"""Lexical analyzer (also known as scanner or tokenizer)This method is responsible for breaking a sentenceapart into tokens. One token at a time."""while self.current_char is not None:if self.current_char.isspace():self.skip_whitespace()continueif self.current_char.isalpha():return self._id()if self.current_char.isdigit():return Token(INTEGER, self.integer())if self.current_char == ':' and self.peek() == '=':self.advance()self.advance()return Token(ASSIGN, ':=')if self.current_char == ';':self.advance()return Token(SEMI, ';')if self.current_char == '+':self.advance()return Token(PLUS, '+')if self.current_char == '-':self.advance()return Token(MINUS, '-')if self.current_char == '*':self.advance()return Token(MUL, '*')if self.current_char == '/':self.advance()return Token(DIV, '/')if self.current_char == '(':self.advance()return Token(LPAREN, '(')if self.current_char == ')':self.advance()return Token(RPAREN, ')')if self.current_char == '.':self.advance()return Token(DOT, '.')self.error()return Token(EOF, None)############################################################################### # # # PARSER # # # ###############################################################################class AST(object):passclass BinOp(AST):def __init__(self, left, op, right):self.left = leftself.token = self.op = opself.right = rightclass Num(AST):def __init__(self, token):self.token = tokenself.value = token.valueclass UnaryOp(AST):def __init__(self, op, expr):self.token = self.op = opself.expr = exprclass Compound(AST):"""Represents a 'BEGIN ... END' block"""def __init__(self):self.children = []class Assign(AST):def __init__(self, left, op, right):self.left = leftself.token = self.op = opself.right = rightclass Var(AST):"""The Var node is constructed out of ID token."""def __init__(self, token):self.token = tokenself.value = token.valueclass NoOp(AST):passclass Parser(object):def __init__(self, lexer):self.lexer = lexer# set current token to the first token taken from the inputself.current_token = self.lexer.get_next_token()def error(self):raise Exception('Invalid syntax')def eat(self, token_type):# compare the current token type with the passed token# 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:self.current_token = self.lexer.get_next_token()else:self.error()def program(self):"""program : compound_statement DOT"""node = self.compound_statement()self.eat(DOT)return nodedef compound_statement(self):"""compound_statement: BEGIN statement_list END"""self.eat(BEGIN)nodes = self.statement_list()self.eat(END)root = Compound()for node in nodes:root.children.append(node)return rootdef statement_list(self):"""statement_list : statement| statement SEMI statement_list"""node = self.statement()results = [node]while self.current_token.type == SEMI:self.eat(SEMI)results.append(self.statement())if self.current_token.type == ID:self.error()return resultsdef statement(self):"""statement : compound_statement| assignment_statement| empty"""if self.current_token.type == BEGIN:node = self.compound_statement()elif self.current_token.type == ID:node = self.assignment_statement()else:node = self.empty()return nodedef assignment_statement(self):"""assignment_statement : variable ASSIGN expr"""left = self.variable()token = self.current_tokenself.eat(ASSIGN)right = self.expr()node = Assign(left, token, right)return nodedef variable(self):"""variable : ID"""node = Var(self.current_token)self.eat(ID)return nodedef empty(self):"""An empty production"""return NoOp()def expr(self):"""expr : term ((PLUS | MINUS) term)*"""node = self.term()while self.current_token.type in (PLUS, MINUS):token = self.current_tokenif token.type == PLUS:self.eat(PLUS)elif token.type == MINUS:self.eat(MINUS)node = BinOp(left=node, op=token, right=self.term())return nodedef term(self):"""term : factor ((MUL | DIV) factor)*"""node = self.factor()while self.current_token.type in (MUL, DIV):token = self.current_tokenif token.type == MUL:self.eat(MUL)elif token.type == DIV:self.eat(DIV)node = BinOp(left=node, op=token, right=self.factor())return nodedef factor(self):"""factor : PLUS factor| MINUS factor| INTEGER| LPAREN expr RPAREN| variable"""token = self.current_tokenif token.type == PLUS:self.eat(PLUS)node = UnaryOp(token, self.factor())return nodeelif token.type == MINUS:self.eat(MINUS)node = UnaryOp(token, self.factor())return nodeelif token.type == INTEGER:self.eat(INTEGER)return Num(token)elif token.type == LPAREN:self.eat(LPAREN)node = self.expr()self.eat(RPAREN)return nodeelse:node = self.variable()return nodedef parse(self):"""program : compound_statement DOTcompound_statement : BEGIN statement_list ENDstatement_list : statement| statement SEMI statement_liststatement : compound_statement| assignment_statement| emptyassignment_statement : variable ASSIGN exprempty :expr: term ((PLUS | MINUS) term)*term: factor ((MUL | DIV) factor)*factor : PLUS factor| MINUS factor| INTEGER| LPAREN expr RPAREN| variablevariable: ID"""node = self.program()if self.current_token.type != EOF:self.error()return node############################################################################### # # # INTERPRETER # # # ###############################################################################class NodeVisitor(object):def visit(self, node):method_name = 'visit_' + type(node).__name__visitor = getattr(self, method_name, self.generic_visit)return visitor(node)def generic_visit(self, node):raise Exception('No visit_{} method'.format(type(node).__name__))class Interpreter(NodeVisitor):GLOBAL_SCOPE = {}def __init__(self, parser):self.parser = parserdef visit_BinOp(self, node):if node.op.type == PLUS:return self.visit(node.left) + self.visit(node.right)elif node.op.type == MINUS:return self.visit(node.left) - self.visit(node.right)elif node.op.type == MUL:return self.visit(node.left) * self.visit(node.right)elif node.op.type == DIV:return self.visit(node.left) // self.visit(node.right)def visit_Num(self, node):return node.valuedef visit_UnaryOp(self, node):op = node.op.typeif op == PLUS:return +self.visit(node.expr)elif op == MINUS:return -self.visit(node.expr)def visit_Compound(self, node):for child in node.children:self.visit(child)def visit_Assign(self, node):var_name = node.left.valueself.GLOBAL_SCOPE[var_name] = self.visit(node.right)def visit_Var(self, node):var_name = node.valueval = self.GLOBAL_SCOPE.get(var_name)if val is None:raise NameError(repr(var_name))else:return valdef visit_NoOp(self, node):passdef interpret(self):tree = self.parser.parse()if tree is None:return ''return self.visit(tree)def main():import systext = open(sys.argv[1], 'r').read()lexer = Lexer(text)parser = Parser(lexer)interpreter = Interpreter(parser)result = interpreter.interpret()print(interpreter.GLOBAL_SCOPE)if __name__ == '__main__':main()

在spi.py文件所在的文件夾打開控制臺，運行結果：

C:\Users\Administrator\Desktop\編譯原理\python>python Python 3.6.8 (tags/v3.6.8:3c6b436a57, Dec 24 2018, 00:16:47) [MSC v.1916 64 bit (AMD64)] on win32 Type "help", "copyright", "credits" or "license" for more information. >>> from spi import Lexer >>> lexer = Lexer('BEGIN a := 2; END.') >>> lexer.get_next_token() Token(BEGIN, 'BEGIN') >>> lexer.get_next_token() Token(ID, 'a') >>> lexer.get_next_token() Token(ASSIGN, ':=') >>> lexer.get_next_token() Token(INTEGER, 2) >>> lexer.get_next_token() Token(SEMI, ';') >>> lexer.get_next_token() Token(END, 'END') >>> lexer.get_next_token() Token(DOT, '.') >>> lexer.get_next_token() Token(EOF, None) >>>

spi_lexer

# -*- coding: utf-8 -*- """ @File : spi_lexer.py @Time : 2021/8/2 10:02 @Author : Dontla @Email : sxana@qq.com @Software: PyCharm """ ############################################################################### # # # LEXER # # # ################################################################################ Token types # # EOF (end-of-file) token is used to indicate that # there is no more input left for lexical analysis (INTEGER, PLUS, MINUS, MUL, DIV, LPAREN, RPAREN, ID, ASSIGN,BEGIN, END, SEMI, DOT, EOF) = ('INTEGER', 'PLUS', 'MINUS', 'MUL', 'DIV', '(', ')', 'ID', 'ASSIGN','BEGIN', 'END', 'SEMI', 'DOT', 'EOF' )class Token(object):def __init__(self, type, value):self.type = typeself.value = valuedef __str__(self):"""String representation of the class instance.Examples:Token(INTEGER, 3)Token(PLUS, '+')Token(MUL, '*')"""return 'Token({type}, {value})'.format(type=self.type,value=repr(self.value))def __repr__(self):return self.__str__()RESERVED_KEYWORDS = {'BEGIN': Token('BEGIN', 'BEGIN'),'END': Token('END', 'END'), }class Lexer(object):def __init__(self, text):# client string input, e.g. "4 + 2 * 3 - 6 / 2"self.text = text# self.pos is an index into self.textself.pos = 0self.current_char = self.text[self.pos]def error(self):raise Exception('Invalid character')def advance(self):"""Advance the `pos` pointer and set the `current_char` variable."""self.pos += 1if self.pos > len(self.text) - 1:self.current_char = None # Indicates end of inputelse:self.current_char = self.text[self.pos]def peek(self):peek_pos = self.pos + 1if peek_pos > len(self.text) - 1:return Noneelse:return self.text[peek_pos]def skip_whitespace(self):while self.current_char is not None and self.current_char.isspace():self.advance()def integer(self):"""Return a (multidigit) integer consumed from the input."""result = ''while self.current_char is not None and self.current_char.isdigit():result += self.current_charself.advance()return int(result)def _id(self):"""Handle identifiers and reserved keywords"""result = ''# isalnum() 函數檢測至少有一個字符并且所有字符都是字母或數字則返回 True,否則返回 Falsewhile self.current_char is not None and self.current_char.isalnum():result += self.current_charself.advance()# get()函數返回字典指定鍵的值，如果鍵不存在，則返回get第二個參數的值（可選）# 如果字母數字字符串在保留字內則返回保留字字典中的值，否則返回Token(ID, result)token = RESERVED_KEYWORDS.get(result, Token(ID, result))return tokendef get_next_token(self):"""Lexical analyzer (also known as scanner or tokenizer)This method is responsible for breaking a sentenceapart into tokens. One token at a time."""while self.current_char is not None:if self.current_char.isspace():self.skip_whitespace()continueif self.current_char.isalpha():return self._id()if self.current_char.isdigit():return Token(INTEGER, self.integer())# “:=”同時做判斷if self.current_char == ':' and self.peek() == '=':self.advance()self.advance()return Token(ASSIGN, ':=')if self.current_char == ';':self.advance()return Token(SEMI, ';')if self.current_char == '+':self.advance()return Token(PLUS, '+')if self.current_char == '-':self.advance()return Token(MINUS, '-')if self.current_char == '*':self.advance()return Token(MUL, '*')if self.current_char == '/':self.advance()return Token(DIV, '/')if self.current_char == '(':self.advance()return Token(LPAREN, '(')if self.current_char == ')':self.advance()return Token(RPAREN, ')')if self.current_char == '.':self.advance()return Token(DOT, '.')self.error()return Token(EOF, None)if __name__ == '__main__':lexer = Lexer('BEGIN a := 2; END.')while True:token = lexer.get_next_token()print(token)if token.type == EOF:break

運行結果：

D:\python_virtualenv\my_flask\Scripts\python.exe C:/Users/Administrator/Desktop/編譯原理/python/spi_lexer.py Token(BEGIN, 'BEGIN') Token(ID, 'a') Token(ASSIGN, ':=') Token(INTEGER, 2) Token(SEMI, ';') Token(END, 'END') Token(DOT, '.') Token(EOF, None)進程已結束,退出代碼0

總結

以上是生活随笔為你收集整理的【编译原理】构建一个简单的解释器（Let’s Build A Simple Interpreter. Part 9.）（笔记）语法分析（未完，先搁置了！）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。