python脚本处理------正则表达式提取关键字

使用到的 API

re 正则表达式api
argparse 做参数配置
gzip 对 .gz 格式的文件做解码操作

关键使用方法

re.sub()
re.findall()
gzip.open()
line.decode()

import gzip
import argparse
import re


parse = argparse.ArgumentParser()
# set root dir
parse.add_argument('--root_path','-r',default='/root/dir_ip_path',help='root dir path')
args = parse.parse_args()

root_path = args.root_path

### 正则表达式 提取 path 中的 关键字 --- ip
ip_search = r'/root/dir/(.*?)_path'
### get ip name
ip_name = re.findall(ip_search,root_path)[0]

## get macro path && memory list path
## 指定 root/dir_ip_path 内部子文件 ，后者有 .gz 文件，需要特殊处理
macro_path = "{0}/data/{1}.macro.ref.list".format(root_path,ip_name)
memory_list_path = "{0}/reports/synthesis/{1}.mapped.qor.rpt.gz".format(root_path,ip_name)

## get macro dict {Macro Count : ***}
## 用 常规的遍历方法 得到 macro count 个数
macro_file = open(macro_path,'r')
for line in macro_file.readlines():
    if ("Macro Count" not in line):
        continue
    else:
        line = line.split("\n")[0]
        macro_count = line.split(":")[1].split(" ")[1]
macro_file.close()


## read .gz file (need to decode)
memory_list_file = gzip.open(memory_list_path,'rb')


with open('./{}_memory_list.txt'.format(ip_name),'w') as f0:
    ip_clk0 = False
    ip_clk1 = False
    ip_clk2 = False
    for line in memory_list_file.readlines():
        ll = line.decode()
        f0.write(ll)
        if ("ip_clk0" in ll):
            ip_clk0 = True
        if ("ip_clk1" in ll):
            ip_clk1 = True
        if ("ip_clk2" in ll):
            ip_clk2 = True   
f0.close()


memory_txt = open('./{}_memory_list.txt'.format(ip_name)).read()
########## remove '/n' and '/*'   使用 re.sub 去掉转义字符
###### Regular expressions can only handle consecutive lines
memory_oneline = re.sub('\s+','',memory_txt).strip()

## 使用正则表达式的 re,findall 方法的到   关键信息
ecf_search = r'ecf_clk(.*?)CriticalPathClkPeriod'
ecf_log = re.findall(ecf_search,memory_oneline)[0]
ecf_CriticalPathSlack = ecf_log.split("CriticalPathSlack:")[1]
#print(ecf_CriticalPathSlack)

ecf_ICG_search = r'ecf_clk_TO_ICG(.*?)CriticalPathClkPeriod'
ecf_ICG_log = re.findall(ecf_ICG_search,memory_oneline)[0]
ecf_ICG_CriticalPathSlack = ecf_ICG_log.split("CriticalPathSlack:")[1]


edf_search = r'edf_clk(.*?)CriticalPathClkPeriod'
edf_log = re.findall(edf_search,memory_oneline)[0]
edf_CriticalPathSlack = edf_log.split("CriticalPathSlack:")[1]
#print(edf_CriticalPathSlack)

edf_ICG_search = r'edf_clk_TO_ICG(.*?)CriticalPathClkPeriod'
edf_ICG_log = re.findall(edf_ICG_search,memory_oneline)[0]
edf_ICG_CriticalPathSlack = edf_ICG_log.split("CriticalPathSlack:")[1]


if (ip_clk0 == True):
    ip0_search = r'ip_clk0(.*?)CriticalPathClkPeriod'
    ip0_log = re.findall(ip0_search,memory_oneline)[0]
    ip0_CriticalPathSlack = ip0_log.split("CriticalPathSlack:")[1]
    
    ip0_ICG_search = r'ip_clk0_TO_ICG(.*?)CriticalPathClkPeriod'
    ip0_ICG_log = re.findall(ip0_ICG_search,memory_oneline)[0]
    ip0_ICG_CriticalPathSlack = ip0_ICG_log.split("CriticalPathSlack:")[1]



if (ip_clk1 == True):
    ip1_search = r'ip_clk1(.*?)CriticalPathClkPeriod'
    ip1_log = re.findall(ip1_search,memory_oneline)[0]
    ip1_CriticalPathSlack = ip1_log.split("CriticalPathSlack:")[1]

    ip1_ICG_search = r'ip_clk1_TO_ICG(.*?)CriticalPathClkPeriod'
    ip1_ICG_log = re.findall(ip1_ICG_search,memory_oneline)[0]
    ip1_ICG_CriticalPathSlack = ip1_ICG_log.split("CriticalPathSlack:")[1]


if (ip_clk2 == True):
    ip2_search = r'ip_clk2(.*?)CriticalPathClkPeriod'
    ip2_log = re.findall(ip2_search,memory_oneline)[0]
    ip2_CriticalPathSlack = ip2_log.split("CriticalPathSlack:")[1]

    ip2_ICG_search = r'ip_clk2_TO_ICG(.*?)CriticalPathClkPeriod'
    ip2_ICG_log = re.findall(ip2_ICG_search,memory_oneline)[0]
    ip2_ICG_CriticalPathSlack = ip2_ICG_log.split("CriticalPathSlack:")[1]


comb_area_search = r'CombinationalArea:(.*?)NoncombinationalArea'
comb_area = re.findall(comb_area_search,memory_oneline)[0]


noncomb_area_search = r'NoncombinationalArea:(.*?)Buf/InvArea'
noncomb_area = re.findall(noncomb_area_search,memory_oneline)[0]


macro_black_area_search = r'Macro/BlackBoxArea:(.*?)NetArea'
macro_black_area = re.findall(macro_black_area_search,memory_oneline)[0]


## if string have "()" , such as CellArea(netlist) , we need to operation like this :
## ()  change to [(][)]
cell_area_search = r'CellArea[(]netlist[)]:(.*?)CellArea[(]netlistandphysicalonly[)]'
cell_area = re.findall(cell_area_search,memory_oneline)[0]



##   打开一个 txt 文件，追加写入 信息 到 txt 文件中去
with open ('./info.txt','a') as ff:
    ff.write("{}:Macro_Count={}\n".format(ip_name,macro_count))
    ff.write("{}:ecf_clk.Critical Path Slack={}\n".format(ip_name,ecf_CriticalPathSlack))
    ff.write("{}:ecf_clk_TO_ICG.Critical Path Slack={}\n".format(ip_name,ecf_ICG_CriticalPathSlack))
    ff.write("{}:edf_clk.Critical Path Slack={}\n".format(ip_name,edf_CriticalPathSlack))
    ff.write("{}:edf_clk_TO_ICG.Critical Path Slack={}\n".format(ip_name,edf_ICG_CriticalPathSlack))
    if (ip_clk0 == True):
        ff.write("{}:ip_clk0.Critical Path Slack={}\n".format(ip_name,ip0_CriticalPathSlack))
        ff.write("{}:ip_clk0_TO_ICG.Critical Path Slack={}\n".format(ip_name,ip0_ICG_CriticalPathSlack))
    if (ip_clk1 == True):
        ff.write("{}:ip_clk1.Critical Path Slack={}\n".format(ip_name,ip1_CriticalPathSlack))
        ff.write("{}:ip_clk1_TO_ICG.Critical Path Slack={}\n".format(ip_name,ip1_ICG_CriticalPathSlack))
    if (ip_clk2 == True):
        ff.write("{}:ip_clk2.Critical Path Slack={}\n".format(ip_name,ip2_CriticalPathSlack))
        ff.write("{}:ip_clk2_TO_ICG.Critical Path Slack={}\n".format(ip_name,ip2_ICG_CriticalPathSlack))
    
    ff.write("{}:Combinational Area={}\n".format(ip_name,comb_area))
    ff.write("{}:Noncombinational Area={}\n".format(ip_name,noncomb_area))
    ff.write("{}:Macro/Black Box Area={}\n".format(ip_name,macro_black_area))
    ff.write("{}:Cell Area (netlist)={}\n".format(ip_name,cell_area))

ff.close()