编译原理 - PLY实验 - 进制混合运算

链接：我的 github

本案例展示编译原理实验中，对于 PLY 包中 /simple 的使用 Lex 模块来识别 二、八、十六进制的进制混合计算

注意

二进制   (0b|B...) ：0b0110
八进制   (0...)    ：02037
十六进制 (0x|X...) ：0xacf1

结果

>calc (0x02+0X0a)*0X02
>

程序

• 以下只提供一种方法，就是将所有进制的正则识别写在同一个标识符中。
• 另外一种是分开书写，暂时未写完。

# -----------------------------------------------------------------------------
# calc.py
#
# A simple calculator with variables.   This is from O'Reilly's
# "Lex and Yacc", p. 63.
# -----------------------------------------------------------------------------

import sys

sys.path.insert(0, "../..")

if sys.version_info[0] >= 3:
    raw_input = input

tokens = (
    'NAME', 'NUMBER'
)

literals = ['=', '+', '-', '*', '/', '(', ')']

# Tokens
t_NAME = r'[a-zA-Z_][a-zA-Z0-9_]*'

import re
def t_NUMBER(t):
    # r'0(b|B)[0|1]+|0(x|X)[0-9A_Fa_f]+|0[0-7]+'
    r'0(b|B)[0|1]+|0(x|X)[0-9A_Fa_f]+|0[0-7]+|[1-9]\d*'

    # print(re.search('0(b|B)[0|1]+', t.value))
    # print(re.search('0(x|X)[0-9A_Fa_f]+', t.value))
    # print(re.search('0[0-7]+', t.value))
    # print(re.search('[1-9]\d*', t.value))

    if re.search('0(b|B)[0|1]+', t.value):
        t.value = t.value[2:]
        t.value = int(t.value, 2)

    elif re.search('0(x|X)[0-9A_Fa_f]+', t.value):
        t.value = t.value[2:]
        t.value = int(t.value, 16)

    elif re.search('0[0-7]+', t.value):
        t.value = t.value[1:]
        t.value = int(t.value, 8)

    elif re.search('[1-9]\d*', t.value):
        t.value = int(t.value)
        return t

    return t

# 0x02+0X0a+0001+0b01
# (0x02+0X0a)*0X02

t_ignore = " \t"  # 自动删掉” “和”\t“


def t_newline(t):
    r'\n+'
    t.lexer.lineno += t.value.count("\n")


def t_error(t):
    print("Illegal character '%s'" % t.value[0])
    t.lexer.skip(1)


# Build the lexer
import ply.lex as lex

lex.lex()

# Parsing rules

precedence = (
    ('left', '+', '-'),
    ('left', '*', '/'),
    ('right', 'UMINUS'),
)

# dictionary of names
names = {}


def p_statement_assign(p):
    'statement : NAME "=" expression'
    names[p[1]] = p[3]


def p_statement_expr(p):
    'statement : expression'
    # print(hex(p[1]))
    print(p[1])


def p_expression_binop(p):
    '''expression : expression '+' expression
                  | expression '-' expression
                  | expression '*' expression
                  | expression '/' expression'''
    if p[2] == '+':
        p[0] = p[1] + p[3]
    elif p[2] == '-':
        p[0] = p[1] - p[3]
    elif p[2] == '*':
        p[0] = p[1] * p[3]
    elif p[2] == '/':
        p[0] = p[1] / p[3]


def p_expression_uminus(p):
    "expression : '-' expression %prec UMINUS"
    p[0] = -p[2]


def p_expression_group(p):
    "expression : '(' expression ')'"
    p[0] = p[2]


def p_expression_number(p):
    "expression : NUMBER"
    p[0] = p[1]


def p_expression_name(p):
    "expression : NAME"
    try:
        p[0] = names[p[1]]
    except LookupError:
        print("Undefined name '%s'" % p[1])
        p[0] = 0


def p_error(p):
    if p:
        print("Syntax error at '%s'" % p.value)
    else:
        print("Syntax error at EOF")


import ply.yacc as yacc

yacc.yacc()

while 1:
    try:
        s = raw_input('calc > ')
    except EOFError:
        break
    if not s:
        continue
    yacc.parse(s)