PLYを使用した論理式の解析

Question

Q（a）とR（b）が述語で常にPLYを使用して、(Q(a)=>R(b))のようなカッコで「implies」と「 'or」と「negation」を含む論理式を解析しようとしています。ブロック文字と変数 'a'で始まり、 'b'は単一の小文字になります。

各演算子とそのオペランドは括弧で囲まれます。解析しようとしている論理式のいくつかの他の例は((D(q,w) & E(r,s)) => F(t)), (((G(a)=>H(b))=>I(c))=>J(d)), (~(~(~P(a))))です。以下は

「（」、私は対応するために、私のコードを変更することはできませんよ、私は

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

tokens = [ 
    'LPAREN', 
    'RPAREN', 
    'PREDICATE', 
    'AND', 
    'OR', 
    'IMPLIES', 
    'NEGATION' 
] 

t_PREDICATE = r'[A-Z][a-z]*\(([A-Za-z,]+)\)' 
t_LPAREN = r'\(' 
t_RPAREN = r'\)' 
t_AND = r'\&' 
t_OR = r'\|' 
t_IMPLIES = r'\=>' 
t_NEGATION = r'\~' 

t_ignore = r' ' 

def t_error(t): 
    print("Illegeal characters") 
    t.lexer.skip(1) 

lexer = lex.lex() 


def p_expression_negation(p): 
    ''' 
    expression : LPAREN NEGATION PREDICATE RPAREN 

    ''' 
    p[0] = (p[2], p[3]) 
    print(p[0]) 

def p_expression_single(p): 
    ''' 
    expression : PREDICATE 
    ''' 
    p[0] = p[1] 
    print(p[0]) 

def p_expression(p): 
    ''' 
    expression : LPAREN term IMPLIES term RPAREN 
       | LPAREN term AND term RPAREN 
       | LPAREN term OR term RPAREN 
    ''' 

    p[0] = (p[3], p[2], p[4]) 
    print(p[0]) 

def p_term_negation(p): 
    ''' 
    term : LPAREN NEGATION PREDICATE RPAREN 

    ''' 
    p[0] = (p[2], p[3]) 
    return p[0] 


def p_term_single(p): 
    ''' 
    term : PREDICATE 
    ''' 
    p[0] = (p[1]) 
    return p[0] 

def p_term_multiple(p): 
    ''' 
    term : LPAREN PREDICATE IMPLIES PREDICATE RPAREN 
     | LPAREN PREDICATE AND PREDICATE RPAREN 
     | LPAREN PREDICATE OR PREDICATE RPAREN 

    ''' 
    p[0] = (p[3], p[2], p[4]) 
    return p[0] 


def p_error(p): 
    print("Syntax error in input!") 

parser = yacc.yacc() 

while True: 
    try: 
     s = input('Enter the input') 
    except EOFError: 
     break 
    parser.parse(s, lexer=lexer) 

を書かれている。しかし、これらの式は、2つ以上で始まるので、このプログラムは、(((G(a)=>H(b))=>I(c))=>J(d)), (~(~(~P(a))))として論理式のために失敗したコードです式の先頭に括弧を開くような場合には、1からnまでの範囲であることができる。

を私も私のために失敗していることを私は再帰を使うべきだと思うけど。

をこれはとてもできPLYと私の最初のプログラムではありませんyaccのための適切な文法規則を書くには、誰かが私にこれを手伝ってくれると助けになるでしょう

Answer 1

私はtermをどこで使うべきか覚えていません。

EDIT：

前のバージョンQ(a)=>R(b)が正しい表現として扱われたため、理想的ではありませんでした。

現在のバージョンでは、不正な表現としてQ(a)=>R(b)が扱われます。

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

tokens = [ 
    'LPAREN', 
    'RPAREN', 
    'PREDICATE', 
    'AND', 
    'OR', 
    'IMPLIES', 
    'NEGATION' 
] 

t_PREDICATE = r'[A-Z][a-z]*\(([A-Za-z,]+)\)' 
t_LPAREN = r'\(' 
t_RPAREN = r'\)' 
t_AND = r'\&' 
t_OR = r'\|' 
t_IMPLIES = r'\=>' 
t_NEGATION = r'\~' 

t_ignore = r' ' 

def t_error(t): 
    print("Illegeal characters") 
    t.lexer.skip(1) 

lexer = lex.lex() 


def p_expression_normal(p): 
    ''' 
    expression : LPAREN PREDICATE RPAREN 
    ''' 
    p[0] = ('()', p[2]) 
    print(p[0]) 

def p_expression_negation(p): 
    ''' 
    expression : LPAREN NEGATION PREDICATE RPAREN 
       | LPAREN NEGATION expression RPAREN 
    ''' 
    p[0] = ('()', p[2], p[3]) 
    print(p[0]) 

def p_expression_operation(p): 
    ''' 
    expression : LPAREN expression IMPLIES expression RPAREN 
       | LPAREN expression AND expression RPAREN 
       | LPAREN expression OR expression RPAREN 
       | LPAREN PREDICATE IMPLIES expression RPAREN 
       | LPAREN PREDICATE AND expression RPAREN 
       | LPAREN PREDICATE OR expression RPAREN 
       | LPAREN expression IMPLIES PREDICATE RPAREN 
       | LPAREN expression AND PREDICATE RPAREN 
       | LPAREN expression OR PREDICATE RPAREN 
       | LPAREN PREDICATE IMPLIES PREDICATE RPAREN 
       | LPAREN PREDICATE AND PREDICATE RPAREN 
       | LPAREN PREDICATE OR PREDICATE RPAREN    
    ''' 
    p[0] = ('()', p[3], p[2], p[4]) 
    print(p[0]) 

def p_error(p): 
    print("Syntax error in input!") 

parser = yacc.yacc() 


#while True: 
# try: 
#  s = input('Enter the input: ') 
# except EOFError: 
#  break 
# parser.parse(s, lexer=lexer) 

test = [ 
    '(Q(a))', # OK 
    'Q(a)', # wrong 
    '(Q(a)=>R(b))', # OK 
    'Q(a)=>R(b)', # wrong 
    '(((G(a)=>H(b))=>I(c))=>J(d))', # OK 
    '((G(a)=>H(b))=>I(c))=>J(d)', # wrong 
    '(~(~(~P(a))))', # OK 
    '~(~(~P(a)))', # wrong 
    '((D(q,w) & E(r,s)) => F(t))', # OK 
    '(D(q,w) & E(r,s)) => F(t)', # wrong 
] 

for s in test: 
    print(s) 
    print() 
    parser.parse(s, lexer=lexer) 
    print('\n------\n')