python開發編譯器

時間  2019-12-20
標籤 python 開發 編譯器 欄目 Python 简体版
原文   原文鏈接

引言

最近剛剛用python寫完了一個解析protobuf文件的簡單編譯器，深感ply實現詞法分析和語法分析的簡潔方便。乘着餘熱未過，頭腦清醒，記下一點總結和心得，方便各位pythoner參考使用。html

ply使用

簡介

若是你不是從事編譯器或者解析器的開發工做，你可能從未據說過ply。ply是基於python的lex和yacc，而它的做者就是大名鼎鼎Python Cookbook, 3rd Edition的做者。可能有些朋友就納悶了，我一個業務開發怎麼須要本身寫編譯器呢，各位編程大牛說過，中央決定了，要多嘗試新的東西。並且瞭解一些語法解析的姿式，之後本身解析格式複雜的日誌或者數學公式，也是很是有幫助的。python

針對沒有編譯基礎的童鞋，強烈建議瞭解一些文法相關的基本概念。輪子哥強烈推薦的parsing techniques以及編譯龍虎鯨書，我的感受都不適合入門學習，在此推薦胡倫俊的編譯原理（電子工業出版社），針對概念的例子講解不少，很適合入門學習。固然也不須要特別深刻研究，知道詞法分析和語法分析的相關概念和方法就能夠愉快的使用ply了。文檔連接： http://www.pchou.info/open-source/2014/01/18/52da47204d4cb.htmlc++

爲了方便你們上手，以求解多元一次方程組爲例，講解一下ply的使用。git

例子說明

輸入是多個格式爲x + 4y - 3.2z = 7的一次方程，爲了讓例子儘量簡單，作以下限制：github

  • 每一個方程含有變量的部分在等號左邊，常數在等號右邊
  • 每一個方程不限制變量的個數以及變量的順序，但每一個方程每一個變量只容許出現一次
  • 變量的命令規則爲小寫字母串（x y xx yy abc 均爲合法變量名）
  • 變量的係數限制爲整數和浮點數，浮點數不容許1.4e8的格式，係數和變量緊鄰，且係數不能爲0
  • 方程組和方程組之間用, ;隔開

學過線性代數的童鞋確定知道，只須要將方程組抽象爲矩陣，按照線性代數的方法就能夠解決。所以只須要將輸入方程組解析成右邊的矩陣和變量列表便可，剩下的求解過程就能夠交給線性代數相關的工具解決。正則表達式

 

詞法解析

ply中的lex來作詞法解析，詞法解析的理論有一大堆，可是lex用起來卻很是直觀，就是用正則表達式的方式將文本字符串解析爲一個一個的token，下面的代碼就是用lex實現詞法解析。算法

# coding=utf-8

from ply import lex

# 空格 製表符 回車這些不可見符號都忽略
t_ignore = ' \t\r'

# 解析錯誤的時候直接拋出異常
def t_error(t):
    raise Exception('error {} at line {}'.format(t.value[0], t.lineno))

# 記錄行號，方便出錯定位
def t_newline(t):
    r'\n+'
    t.lexer.lineno += len(t.value)

# 支持c++風格的\\註釋
def t_ignore_COMMENT(t):
    r'\/\/[^\n]*'

# 變量的命令規則
def t_VARIABLE(t):
    r'[a-z]+'
    return t

# 常數命令規則
def t_CONSTANT(t):
    r'\d+(\.\d+)?'
    t.value = float(t.value)
    return t

# 輸入中支持的符號頭token，固然也支持t_PLUS = r'\+'的方式將加號定義爲token
literals = '+-,;='
tokens = ('VARIABLE', 'CONSTANT')


if __name__ == '__main__':
    data = '''
    -x + 2.4y + z = 0; //this is a comment
    9y - z + 7.2x = -1;
    y - z + x = 8
    '''

    lexer = lex.lex()
    lexer.input(data)
    while True:
        tok = lexer.token()
        if not tok:
            break
        print tok

直接運行文件就能夠將解析的token串打印出來，以下所示，詳細的使用文檔能夠參考ply文檔。express

LexToken(-,'-',2,5)
LexToken(VARIABLE,'x',2,6)
LexToken(+,'+',2,8)
LexToken(CONSTANT,2.4,2,10)
LexToken(VARIABLE,'y',2,13)
LexToken(+,'+',2,15)
LexToken(VARIABLE,'z',2,17)
LexToken(=,'=',2,19)
LexToken(CONSTANT,0.0,2,21)
LexToken(;,';',2,22)
LexToken(CONSTANT,9.0,3,48)
LexToken(VARIABLE,'y',3,49)
LexToken(-,'-',3,51)
LexToken(VARIABLE,'z',3,53)
LexToken(+,'+',3,55)
LexToken(CONSTANT,7.2,3,57)
LexToken(VARIABLE,'x',3,60)
LexToken(=,'=',3,62)
LexToken(-,'-',3,64)
LexToken(CONSTANT,1.0,3,65)
LexToken(;,';',3,66)
LexToken(VARIABLE,'y',4,72)
LexToken(-,'-',4,74)
LexToken(VARIABLE,'z',4,76)
LexToken(+,'+',4,78)
LexToken(VARIABLE,'x',4,80)
LexToken(=,'=',4,82)
LexToken(CONSTANT,8.0,4,84)編程

詞法解析另外一列：

# coding=utf-8

# ------------------------------------------------------------
# calclex.py
#
# tokenizer for a simple expression evaluator for
# numbers and +,-,*,/
# ------------------------------------------------------------
import ply.lex as lex

# List of token names.   This is always required
tokens = (
   'NUMBER',
   'PLUS',
   'MINUS',
   'TIMES',
   'DIVIDE',
   'LPAREN',
   'RPAREN',
)

# Regular expression rules for simple tokens
t_PLUS    = r'\+'
t_MINUS   = r'-'
t_TIMES   = r'\*'
t_DIVIDE  = r'/'
t_LPAREN  = r'\('
t_RPAREN  = r'\)'

# A regular expression rule with some action code
def t_NUMBER(t):
    r'\d+'
    t.value = int(t.value)
    return t

# Define a rule so we can track line numbers
def t_newline(t):
    r'\n+'
    t.lexer.lineno += len(t.value)

# A string containing ignored characters (spaces and tabs)
t_ignore  = ' \t'

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

# Build the lexer
lexer = lex.lex()
#爲了使lexer工做，你須要給定一個輸入，並傳遞給input()方法。而後，重複調用token()方法來獲取標記序列，下面的代碼展現了這種用法：

# Test it out
data = '''
3 + 4 * 10
  + -20 *2
'''

# Give the lexer some input
lexer.input(data)

# Tokenize
while True:
    tok = lexer.token()
    if not tok: break      # No more input
    print tok

 

 

直接運行文件就能夠將解析的token串打印出來，以下所示，詳細的使用文檔能夠參考ply文檔。bash

$ python calclex.py
LexToken(NUMBER,3,2,1)
LexToken(PLUS,'+',2,3)
LexToken(NUMBER,4,2,5)
LexToken(TIMES,'*',2,7)
LexToken(NUMBER,10,2,9)
LexToken(PLUS,'+',3,14)
LexToken(MINUS,'-',3,16)
LexToken(NUMBER,20,3,17)
LexToken(TIMES,'*',3,20)
LexToken(NUMBER,2,3,21)

語法解析

ply中的yacc用做語法分析，雖然複雜的詞法分析能夠代替簡單的語法分析，但相似於編程語言的解析再複雜的詞法分析也勝任不了。在使用yacc以前，須要瞭解上下文無關文法，這部份內容太多太雜，我也只瞭解部分簡單的概念，有興趣的能夠看一看編譯原理深刻了解。

目前語法分析的方法有兩大類，即自下向上的分析方法和自上而下的分析方法。所謂自上而下的分下法就是從文法的開始符號出發，根據文法規則正向推到出給定句子的一種方法，或者說，從樹根開始，往下構造語法樹，直到創建每一個樹葉的分析方法。表明算法是LL(1)，此算法文法解析能力不強，對文法定義要求比較高，主流的編譯器都沒有使用。自下而上的分析法是從給定的輸入串開始，根據文法規則逐步進行歸約，直至歸約到文法的開始符號，或者說從語法書的末端開始，步步向上歸約，直至歸約到根節點的分析方法。表明算法有SLR、LRLR，ply使用的就是LRLR。

所以咱們只須要定義文法和規約動做便可，如下就是完整的代碼。

# -*- coding=utf8 -*-

from ply import (
    lex,
    yacc
)

# 空格 製表符 回車這些不可見符號都忽略
t_ignore = ' \t\r'

# 解析錯誤的時候直接拋出異常
def t_error(t):
    raise Exception('error {} at line {}'.format(t.value[0], t.lineno))

# 記錄行號，方便出錯定位
def t_newline(t):
    r'\n+'
    t.lexer.lineno += len(t.value)

# 支持c++風格的\\註釋
def t_ignore_COMMENT(t):
    r'\/\/[^\n]*'

# 變量的命令規則
def t_VARIABLE(t):
    r'[a-z]+'
    return t

# 常數命令規則
def t_CONSTANT(t):
    r'\d+(\.\d+)?'
    t.value = float(t.value)
    return t

# 輸入中支持的符號頭token，固然也支持t_PLUS = r'\+'的方式將加號定義爲token
literals = '+-,;='
tokens = ('VARIABLE', 'CONSTANT')

# 頂層文法，規約的時候equations對應的p[1]是一個列表，包含了方程左邊各個變量與係數還有方程左邊的常數
def p_start(p):
    """start : equations"""
    var_count, var_list = 0, []
    for left, _ in p[1]:
        for con, var_name in left:
            if var_name in var_list:
                continue
            var_list.append(var_name)
            var_count += 1

    matrix = [[0] * (var_count + 1) for _ in xrange(len(p[1]))]
    for counter, eq in enumerate(p[1]):
        left, right = eq
        for con, var_name in left:
            matrix[counter][var_list.index(var_name)] = con
        matrix[counter][-1] = -right

    var_list.append(1)
    p[0] = matrix, var_list

# 方程組對應的文法，每一個方程用，或者；作分隔
def p_equations(p):
    """equations : equation ',' equations
                 | equation ';' equations
                 | equation"""
    if len(p) == 2:
        p[0] = [p[1]]
    else:
        p[0] = [p[1]] + p[3]

# 單個方程對應的文法
def p_equation(p):
    """equation : eq_left '=' eq_right"""
    p[0] = (p[1], p[3])

# 方程等式左邊對應的文法
def p_eq_left(p):
    """eq_left : var_unit eq_left
               |"""
    if len(p) == 1:
        p[0] = []
    else:
        p[0] = [p[1]] + p[2]

# 六種文法對應例子： x, 5x, +x, -x, +4x, -4y
# 歸約的形式是一個元組，例： (5, 'x')
def p_var_unit(p):
    """var_unit : VARIABLE
                | CONSTANT VARIABLE
                | '+' VARIABLE
                | '-' VARIABLE
                | '+' CONSTANT VARIABLE
                | '-' CONSTANT VARIABLE"""
    len_p = len(p)
    if len_p == 2:
        p[0] = (1.0, p[1])
    elif len_p == 3:
        if p[1] == '+':
            p[0] = (1.0, p[2])
        elif p[1] == '-':
            p[0] = (-1.0, p[2])
        else:
            p[0] = (p[1], p[2])
    else:
        if p[1] == '+':
            p[0] = (p[2], p[3])
        else:
            p[0] = (-p[2], p[3])

# 方程等式右邊對應的常數，對應的例子：1.2， +1.2， -1.2
def p_eq_right(p):
    """eq_right : CONSTANT
                | '+' CONSTANT
                | '-' CONSTANT"""
    if len(p) == 3:
        if p[1] == '-':
            p[0] = -p[2]
        else:
            p[0] = p[2]
    else:
        p[0] = p[1]

if __name__ == '__main__':
    data = '''
    -x + 2.4y + z = 0; //this is a comment
    9y - z + 7.2x = -1;
    y - z + x = 8
    '''

    lexer = lex.lex()
    parser = yacc.yacc(debug=True)
    lexer.lineno = 1
    s = parser.parse(data)
    print s

直接運行文件便可，獲得的輸出以下，以後就能夠根據線性代數的方法求解各個變量的值

WARNING: no p_error() function is defined
Generating LALR tables
([[-1.0, 2.4, 1.0, -0.0], [7.2, 9.0, -1.0, 1.0], [1.0, 1.0, -1.0, -8.0]], ['x', 'y', 'z', 1])

總結

依託於python簡潔的語法，ply爲咱們提供了一個強大的語法分析工具，更復雜的例子能夠參考https://github.com/LiuRoy/proto_parser，這是我用ply實現的一個簡單的protobuf解析器，用於減小頻繁的中間文件生成。有這種神器，一顆賽艇！

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程