使用 Python Yacc\Lex 作为公式解析器

在使用 Python Yacc/Lex 实现一个公式解析器，旨在将公式字符串转换成一组类定义的操作数。在解析规则的定义过程中遇到了一些困难，包括括号的歧义以及移进-规约冲突。

目前遇到的问题

• 括号的歧义：需要允许使用任意匹配的括号，但括号的使用方式带来了很多困惑，并且由此产生了移进-规约错误。对于特定任务的应用，括号非常必要，需要明确地评估公式。
• 移进-规约冲突：在解析器定义中存在移进-规约冲突，需要解决这些冲突以确保解析器的正确性。

解决方案

为了解决这些问题，可以使用以下策略：

1. 优化解析规则：重新定义解析规则，以减少括号歧义和移进-规约冲突。例如，可以将括号的使用限制在特定的情况下，或者使用显式的优先级规则来解决冲突。
2. 使用更强大的解析库：在某些情况下，可以使用更强大的解析库来解决上述问题。例如，pyparsing 库提供了强大的解析功能，可以更好地处理括号歧义和移进-规约冲突。
3. 明确定义优先级：在语法中明确定义运算符的优先级，以便解析器能够正确处理括号和优先级问题。

代码示例

以下是以 Python Yacc/Lex 为基础实现的公式解析器代码示例，可供参考：

import ply.yacc as yacc
import ply.lex as lex

# Define tokens
tokens = (
    'NEGATION',
    'FUTURE',
    'GLOBAL',
    'NEXT',
    'CONJUNCTION',
    'DISJUNCTION',
    'EQUIVALENCE',
    'IMPLICATION',
    'PROPOSITION',
    'LPAREN',
    'RPAREN',
    'TRUE',
    'FALSE',
)

# Define regular expressions for tokens
t_NEGATION    = r'[\s]*\![\s]*'
t_FUTURE      = r'[\s]*AF[\s]*'
t_GLOBAL      = r'[\s]*AG[\s]*'
t_NEXT        = r'[\s]*AX[\s]*'
t_CONJUNCTION = r'[\s]*\&[\s]*'
t_DISJUNCTION = r'[\s]*\|[\s]*'
t_EQUIVALENCE = r'[\s]*\<\-\>[\s]*'
t_IMPLICATION = r'[\s]*[^<]\-\>[\s]*'
t_LPAREN      = r'[\s]*\([\s]*'
t_RPAREN      = r'[\s]*\)[\s]*'
t_PROPOSITION = r'[\s]*[a-z]+[-\w\._]*[\s]*'
t_TRUE        = r'[\s]*TRUE[\s]*'
t_FALSE       = r'[\s]*FALSE[\s]*'

# Define precedence rules
precedence = (
    ('left', 'ASSIGNMENT'),
    ('left', 'NEGATION'),
    ('left', 'GLOBAL','NEXT','FUTURE'),
    ('left', 'CONJUNCTION'),
    ('left', 'DISJUNCTION'),
    ('left', 'EQUIVALENCE'),
    ('left', 'IMPLICATION'),
    ('left', 'AUB', 'AUM'),
    ('left', 'LPAREN', 'RPAREN', 'TRUE', 'FALSE'),
)

# Define parser rules
def p_double_neg_paren(p):
    '''formula : NEGATION LPAREN NEGATION LPAREN PROPOSITION RPAREN RPAREN
    '''
    stack.append(p[5].strip())

def p_double_neg(p):
    '''formula : NEGATION NEGATION PROPOSITION
    '''
    stack.append(p[3].strip())

def p_double_neg_inner_paren(p):
    '''formula : NEGATION NEGATION LPAREN PROPOSITION RPAREN
    '''
    stack.append(p[4].strip())

def p_double_neg_mid_paren(p):
    '''formula : NEGATION LPAREN NEGATION PROPOSITION RPAREN
    '''
    stack.append(p[4].strip())

def p_groupAssignment(p):
    '''formula : PROPOSITION ASSIGNMENT ASSIGNVAL
    '''
    stack.append(p[1].strip() + p[2].strip() + p[3].strip())

def p_neg_paren_take_outer_token(p):
    '''formula : NEGATION LPAREN PROPOSITION RPAREN
               | NEGATION LPAREN TRUE RPAREN
               | NEGATION LPAREN FALSE RPAREN
    '''
    stack.append(Neg(p[3]))

def p_neg_take_outer_token(p):
    '''formula : NEGATION PROPOSITION
               | NEGATION TRUE
               | NEGATION FALSE
    '''

    stack.append(Neg(p[2].strip()))

def p_neg_take_outer_token_paren