编写非上下文无关语言的编程语言

当我们想要编写一门编程语言时，通常会选择使用上下文无关语法，因为这种语法相对简单，易于解析。

• 但是，有些编程语言，比如 Python，使用了缩进作为语法的一部分。而缩进无法用上下文无关语法来表示。
• 因此，如果我们想要编写一门非上下文无关的编程语言，我们需要寻找新的解决方案。

2. 解决方案

• 一种解决方案是使用上下文相关语法。上下文相关语法允许我们使用符号表来解析代码，这使得我们可以处理缩进等语法特性。
• 另一种解决方案是使用手工编写的解析器。手工编写的解析器可以让我们完全控制解析过程，因此我们可以处理任何类型的语法。
• 还有一种解决方案是使用 parser generator（解析器生成器），parser generator 可以帮助我们自动生成解析器。

代码例子

• 下面是一个使用上下文相关语法编写的 Python 解析器：

import ply.yacc

# 定义语法规则
def p_module(p):
    '''module : statement_list'''
    pass

def p_statement_list(p):
    '''statement_list : statement
                     | statement_list statement'''
    pass

def p_statement(p):
    '''statement : simple_statement
                 | compound_statement'''
    pass

def p_simple_statement(p):
    '''simple_statement : expression_statement
                        | assignment_statement'''
    pass

# ...（省略其他语法规则）

# 定义词法分析器
lexer = ply.lex.lex()

# 定义解析器
parser = ply.yacc.yacc()

# 解析代码
parser.parse(code)

• 下面是一个使用手工编写的解析器编写的 Python 解析器：

class Parser:
    def __init__(self, code):
        self.code = code
        self.pos = 0

    def parse(self):
        # 解析代码
        module = self.parse_module()
        return module

    def parse_module(self):
        # 解析模块
        statement_list = self.parse_statement_list()
        return statement_list

    def parse_statement_list(self):
        # 解析语句列表
        statement_list = []
        while self.pos < len(self.code):
            statement = self.parse_statement()
            statement_list.append(statement)
        return statement_list

    def parse_statement(self):
        # 解析语句
        if self.code[self.pos] == ' ':
            # 解析简单语句
            statement = self.parse_simple_statement()
        else:
            # 解析复合语句
            statement = self.parse_compound_statement()
        return statement

    def parse_simple_statement(self):
        # 解析简单语句
        expression_statement = self.parse_expression_statement()
        return expression_statement

    def parse_compound_statement(self):
        # 解析复合语句
        assignment_statement = self.parse_assignment_statement()
        return assignment_statement

# ...（省略其他解析方法）

# 解析代码
parser = Parser(code)
module = parser.parse()

• 下面是一个使用 parser generator 编写的 Python 解析器：

import lark

# 定义语法规则
grammar = '''
module: statement_list

statement_list: statement
              | statement_list statement

statement: simple_statement
         | compound_statement

simple_statement: expression_statement
                | assignment_statement

...（省略其他语法规则）
'''

# 定义解析器
parser = lark.Lark(grammar)

# 解析代码
module = parser.parse(code)