659 lines
23 KiB
Python
Executable File
659 lines
23 KiB
Python
Executable File
#!/usr/bin/env python3
|
||
# coding=utf-8
|
||
# Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2021-2022. All rights reserved.
|
||
|
||
import os
|
||
import re
|
||
import sys
|
||
import platform
|
||
import string
|
||
import shutil
|
||
import time
|
||
import json
|
||
import xml.etree.ElementTree as ET
|
||
|
||
|
||
py_version = platform.python_version()
|
||
|
||
def timestamp():
|
||
return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time()))
|
||
|
||
##########################################################################
|
||
#
|
||
# 日志内容提取函数
|
||
#
|
||
##########################################################################
|
||
# 日志状态机处理流程：
|
||
# LOG_ENTRY_FINDING -- 查找日志接口
|
||
# LOG_ENTRY_FOUNDED -- 日志接口匹配，查找日志内容
|
||
# LOG_CONT_ENTRY_FINDING -- 日志内容入口匹配，以“号开关，以”号结束
|
||
# LOG_CONT_END_FOUNING -- 日志内容查找
|
||
# LOG_EXIT_FINDING -- 日志线束符匹配
|
||
|
||
# 全局变量
|
||
aich_name = ""
|
||
log_info_list = [] # 日志信息列表，【文件号， 行号， 日志内容】
|
||
g_undefine_id = [] # 保存未定义的FileId
|
||
g_fsm_status = "LOG_ENTRY_FINDING"
|
||
g_log_key_find = 0 # （状态位）判断是否查找到日志关键字，0否1是
|
||
g_log_str = ""
|
||
g_log_str_full = ""
|
||
g_log_entry = [
|
||
r"LOG_PRINT[0-4](\s*)\(",
|
||
r"log_print[0-4](\s*)\(",
|
||
r"acore_log[0-4](\s*)\(",
|
||
r"[printlog]{3,5}_alter(\s*)\(",
|
||
r"[PRINTLOG]{3,5}_ALTER(\s*)\(",
|
||
r"_LOG[0-4]{1,2}(\s*)\(",
|
||
r"(DBG|INFO|ERR|WARN)_LOG(\s*)\(",
|
||
# BTH
|
||
r"(dbg|info|err|warn)_log(\s*)\(",
|
||
r"(dbg|info|err|warn)_log[0-4](\s*)\(",
|
||
# diag common
|
||
r"diag_(error|warning|info|debug)_log(\d*)(\s*)\(",
|
||
r"PRINT_(DEBUG|INFO|ERR|WARN)(\s*)\(",
|
||
r"print_(debug|info|err|warn)(\s*)\(",
|
||
r"_log_(err|warn|info|debug)(\s*)\(",
|
||
# GPU
|
||
r"(vau|dpu|jpeg|gmmu|vg)_(err|info|dbg|print)(\s*)\(",
|
||
# WIFI
|
||
r"oam_(error|warning|info)_log[0-4](\s*)\(",
|
||
r"alg_ar_dbg_log[0-4](\s*)\(",
|
||
r"common_log_dbg[0-4](\s*)\(",
|
||
# GPU
|
||
r"GRAPHIC_LOG(F|E|W|I|D|P)(\s*)\(",
|
||
r"DISP_LOG(E|W|I|D)(\s*)\(",
|
||
r"LV_LOG(E|W|I)(\s*)\(",
|
||
# Meida
|
||
r"ALOG(V|D|I|W|E)(\s*)\(",
|
||
r"MEDIA_(DEBUG|ERR|WARNING|INFO|FATAL)_LOG(\s*)\(",
|
||
r"HMF_LOG(F|E|W|I)(\s*)\(",
|
||
r"MEDIA_HAL_LOG(V|D|I|W|E)(\s*)\(",
|
||
r"CHECK_NULL_(RETURN|RETURN_NONE)(\s*)\(",
|
||
r"CHECK_FAILED_(RETURN|RETURN_NONE|PRINT|RETURN_WITH_UNLOCK)(\s*)\(",
|
||
r"CHK_NULL_(RETURN|RETURN_NONE|RETURN_WITH_UNLOCK)(\s*)\(",
|
||
r"CHK_FAILED_(RETURN|NO_RETURN)(\s*)\(",
|
||
r"(CHK_COND_RETURN|CHK_FALSE_RETURN|CHECK_STATE_SAME_RETURN)(\s*)\(",
|
||
# OHOS
|
||
r"HILOG_(DEBUG|ERROR|FATAL|INFO|WARN)(\s*)\(",
|
||
r"SAMGR_LOG_(ERROR|FATAL|INFO|WARN)(\s*)\(",
|
||
# app
|
||
r"WEARABLE_LOG(D|I|W|E)(\s*)\(",
|
||
# plat
|
||
r"hcc_printf_err_log(\s*)\(",
|
||
# audio
|
||
r"audio_log[0-4](\s*)\(",
|
||
] # 日志关键字规则
|
||
|
||
# DSP日志关键字规则，不要改变顺序，慎重修改
|
||
g_audio_log_entry = [
|
||
r"sap_(alert|fatal|err|warn|dbg|trace)_log_(s32|bool)(\s*)\(",
|
||
r"sap_(alert|fatal|err|warn|dbg|trace)_log_u32(\s*)\(",
|
||
r"sap_(alert|fatal|err|warn|dbg|trace)_log_h32(\s*)\(",
|
||
r"sap_(alert|fatal|err|warn|dbg|trace)_log_float(\s*)\(",
|
||
r"sap_(alert|fatal|err|warn|dbg|trace)_log_void(\s*)\(",
|
||
r"sap_(alert|fatal|err|warn|dbg|trace)_log_ret(\s*)\(",
|
||
r"sap_(alert|fatal|err|warn|dbg|trace)_log_fun(\s*)\(",
|
||
r"sap_(alert|fatal|err|warn|dbg|trace)_log_null_pointer(\s*)\(",
|
||
r"audio_func_enter(\s*)\(",
|
||
r"audio_func_exit(\s*)\(",
|
||
r"sap_(alert|fatal|err|warn|dbg|trace)_log_info(\s*)\(",
|
||
r"audio_log_(alert|fatal|err|warn|dbg|trace)(\s*)\(",
|
||
] # DSP日志关键字规则，不要改变顺序，慎重修改
|
||
|
||
g_audio_log_key_index = -1
|
||
g_audio_log_addition_info = [" = %d",
|
||
" = %u",
|
||
" = 0x%08X",
|
||
" = %f",
|
||
" = %p",
|
||
"Error Code: [0x%08X]",
|
||
" Failed, Error Code: [0x%08X]",
|
||
" = %p, Null Pointer!\\n",
|
||
"enter...",
|
||
"exit..."]
|
||
|
||
g_log_full_cont = '\"(.*)\"\s*[,|)]'
|
||
# 用于记录日志行数，日志多行时可能是第一行，有可能是最后一行；
|
||
# 0 表示第一行 1表示最后一行
|
||
g_log_entry_or_end_flag = -1
|
||
|
||
XML_PATH="build/config/target_config/<chip>/hdb_config/database_cfg/mk_hdb_xml.json"
|
||
|
||
def get_log_level(str):
|
||
m = re.search(r'LOG_LEVEL_ERROR|ERR_LOG|err_log|(GRAPHIC|DISP|LV)_LOGF|(GRAPHIC|DISP|LV)_LOGE|WEARABLE_LOGE|_ERR|print_err|ERROR|FATAL', str)
|
||
if m is not None:
|
||
return 2,'ERROR'
|
||
m = re.search(r'(CHK|CHECK)_NULL_RETURN|(CHK|CHECK)_NULL_RETURN_NONE|(CHK|CHECK)_FAILED_RETURN|CHECK_FAILED_RETURN_NONE', str)
|
||
if m is not None:
|
||
return 2,'ERROR'
|
||
m = re.search(r'CHECK_FAILED_PRINT|CHECK_FAILED_RETURN_WITH_UNLOCK|CHK_NULL_RETURN_WITH_UNLOCK|CHK_FAILED_NO_RETURN', str)
|
||
if m is not None:
|
||
return 2,'ERROR'
|
||
m = re.search(r'CHK_COND_RETURN|CHK_FALSE_RETURN', str)
|
||
if m is not None:
|
||
return 2,'ERROR'
|
||
m = re.search(r'LOG_LEVEL_WARNING|WARN_LOG|warn_log|warning_log|(GRAPHIC|DISP|LV)_LOGW|WEARABLE_LOGW|_WARN|print_warn', str)
|
||
if m is not None:
|
||
return 3,'WARNING'
|
||
m = re.search(r'alg_ar_dbg|common_log_dbg', str)
|
||
if m is not None:
|
||
return 3,'WARNING'
|
||
m = re.search(r'LOG_LEVEL_INFO|INFO_LOG|info_log|(GRAPHIC|DISP|LV)_LOGI|GRAPHIC_LOGP|WEARABLE_LOGI|_INFO|print_info', str)
|
||
if m is not None:
|
||
return 5,'INFO'
|
||
m = re.search(r'CHECK_STATE_SAME_RETURN', str)
|
||
if m is not None:
|
||
return 5,'INFO'
|
||
m = re.search(r'LOG_LEVEL_DBG|(DBG|DEBUG)_LOG|(dbg|debug)_log|(GRAPHIC|DISP|LV)_LOGD|WEARABLE_LOGD|_DEBUG|print_debug', str)
|
||
if m is not None:
|
||
return 6,'DBG'
|
||
|
||
m = re.search(r'_error_log|_log_err|_ERROR_|(vau|dpu|jpeg|gmmu|vg)_err|ALOGE|MEDIA_(ERR|FATAL)_LOG|HMF_LOG(F|E)|MEDIA_HAL_LOGE', str)
|
||
if m is not None:
|
||
return 2,'ERROR'
|
||
m = re.search(r'_warning_log|_log_warn|_WARNING_|ALOGW|HMF_LOGW|MEDIA_HAL_LOGW', str)
|
||
if m is not None:
|
||
return 3,'WARNING'
|
||
m = re.search(r'_info_log|_log_info|_INFO_|(vau|dpu|jpeg|gmmu|vg)_info|ALOGI|MEDIA_INFO_LOG|HMF_LOGI|MEDIA_HAL_LOGI', str)
|
||
if m is not None:
|
||
return 5,'INFO'
|
||
m = re.search(r'_debug_log|_log_debug|(vau|dpu|jpeg|gmmu|vg)_(dbg|print)|ALOG(V|D)|MEDIA_DEBUG_LOG|MEDIA_HAL_LOG(V|D)', str)
|
||
if m is not None:
|
||
return 6,'DBG'
|
||
|
||
print("no match for :%s" % str)
|
||
return 7, 'no match'
|
||
|
||
# DSP日志级别识别，慎重修改
|
||
def get_audio_log_level(str):
|
||
m = re.search(r'_alert|_err|_fatal', str)
|
||
if m is not None:
|
||
return 2,'ERROR'
|
||
m = re.search(r'_warn', str)
|
||
if m is not None:
|
||
return 3,'WARNING'
|
||
m = re.search(r'_trace', str)
|
||
if m is not None:
|
||
return 5,'INFO'
|
||
m = re.search(r'_dbg', str)
|
||
if m is not None:
|
||
return 6,'DBG'
|
||
m = re.search(r'_enter|_exit', str)
|
||
if m is not None:
|
||
return 5,'INFO'
|
||
print("audio log no match for :%s" % str)
|
||
return 7, 'no match'
|
||
|
||
def add_content_to_xml(data, msg_root_element):
|
||
prim_pri = data["LEVEL_STR"]
|
||
prim_sz = data["FMT"]
|
||
prim_line = data["LINE_NUM"]
|
||
prim_file = data["FILE_NAME"]
|
||
prim_file_id = data["FILE_ID"]
|
||
args_count = data["ARGS_COUNT"]
|
||
mod_id = data["MOD_ID"]
|
||
level = data["LEVEL_NUM"]
|
||
|
||
new_element = ET.Element('')
|
||
new_element.tag = 'MSG'
|
||
new_element.attrib['STRUCTURE'] = "%s%d" % ("diag_log_msg", args_count)
|
||
new_element.attrib['NAME'] = "%s @%s(%d),%s" % (prim_sz, prim_file, prim_line, prim_pri)
|
||
|
||
#sdt log_id to hso msg_id
|
||
#log_flg mod_id file_id line_num level
|
||
#1bit 4bit 10bit 14bit 3bit
|
||
msg_id = (1 << 31) | (mod_id << 27) | (prim_file_id << 17) | (prim_line << 3) | level
|
||
new_element.attrib['ID'] = hex(msg_id)
|
||
new_element.tail = '\n\t\t\t'
|
||
msg_root_element.append(new_element)
|
||
|
||
# 根据日志状态机流程逐行解析日志内容
|
||
def parse_log_from_line(line):
|
||
global g_fsm_status
|
||
global g_log_str
|
||
global g_log_str_full
|
||
global g_log_str_full_flag
|
||
global g_log_entry
|
||
global g_log_full_cont
|
||
global g_log_entry_or_end_flag
|
||
global g_log_key_find
|
||
global g_audio_log_key_index
|
||
findkey = 0
|
||
# 匹配日志接口
|
||
if "LOG_ENTRY_FINDING" == g_fsm_status:
|
||
g_log_entry_or_end_flag = -1
|
||
g_audio_log_key_index = -1
|
||
g_log_str = ""
|
||
g_log_str_full = ""
|
||
for x in g_log_entry:
|
||
m = re.search(x, line.strip())
|
||
if m is not None:
|
||
findkey = 1
|
||
break
|
||
if 1 == findkey:
|
||
g_fsm_status = "LOG_ENTRY_FOUNDED"
|
||
g_log_str_full += line
|
||
g_log_entry_or_end_flag = 0
|
||
g_log_key_find = 1
|
||
parse_log_from_line(line)
|
||
|
||
# SAP log
|
||
find_audio_key = 0
|
||
index = 0
|
||
for x in g_audio_log_entry:
|
||
m = re.search(x, line.strip())
|
||
if m is not None:
|
||
find_audio_key = 1
|
||
break
|
||
index = index + 1
|
||
if 1 == find_audio_key:
|
||
g_fsm_status = "LOG_ENTRY_FOUNDED"
|
||
g_log_str_full += line
|
||
g_log_entry_or_end_flag = 0
|
||
g_audio_log_key_index = index
|
||
g_log_key_find = 1
|
||
parse_log_from_line(line)
|
||
else:
|
||
return
|
||
|
||
# 日志接口匹配，确认是否完整日志；确认日志是否正常结束
|
||
elif "LOG_ENTRY_FOUNDED" == g_fsm_status:
|
||
if g_audio_log_key_index >= 0 and g_audio_log_key_index <= 4: # such as "sap_alert_log_u32"
|
||
m1 = re.search("\(\s*(\S+)\s*\)", line)
|
||
if m1 is not None:
|
||
g_log_str = m1.groups()[0] + g_audio_log_addition_info[g_audio_log_key_index] + '\0';
|
||
g_fsm_status = "LOG_EXIT_FINDING"
|
||
parse_log_from_line(line)
|
||
elif g_audio_log_key_index == 5: # such as "sap_fatal_log_err_code"
|
||
m1 = re.search("\(\s*(\w+)\s*\)", line)
|
||
if m1 is not None:
|
||
g_log_str = g_audio_log_addition_info[g_audio_log_key_index] + '\0';
|
||
g_fsm_status = "LOG_EXIT_FINDING"
|
||
parse_log_from_line(line)
|
||
elif g_audio_log_key_index == 6: # such as "sap_err_log_fun_err"
|
||
m1 = re.search("\(\s*(\w+)\s*,", line)
|
||
if m1 is not None:
|
||
g_log_str = "Call " + m1.groups()[0] + g_audio_log_addition_info[g_audio_log_key_index] + '\0';
|
||
g_fsm_status = "LOG_EXIT_FINDING"
|
||
parse_log_from_line(line)
|
||
elif g_audio_log_key_index == 7: # such as "sap_err_log_null_pointer"
|
||
m1 = re.search("\(\s*(\S+)\s*\)", line)
|
||
if m1 is not None:
|
||
g_log_str = m1.groups()[0] + g_audio_log_addition_info[g_audio_log_key_index] + '\0';
|
||
g_fsm_status = "LOG_EXIT_FINDING"
|
||
parse_log_from_line(line)
|
||
elif g_audio_log_key_index == 8 or g_audio_log_key_index == 9: # such as "audio_func_enter"
|
||
m1 = re.search("\(\)", line)
|
||
if m1 is not None:
|
||
g_log_str = g_audio_log_addition_info[g_audio_log_key_index] + '\0';
|
||
g_fsm_status = "LOG_EXIT_FINDING"
|
||
parse_log_from_line(line)
|
||
else:
|
||
m1 = re.search(g_log_full_cont, line) # 完整日志格式
|
||
m2 = re.search("\"(.+)", line) # 部分日志格式 ，引号开头
|
||
if m1 is not None:
|
||
g_log_str = m1.groups()[0] + '\0'
|
||
g_fsm_status = "LOG_EXIT_FINDING"
|
||
parse_log_from_line(line)
|
||
elif m2 is not None:
|
||
g_fsm_status = "LOG_CONT_END_FINDING"
|
||
g_log_str = m2.groups()[0] # 引号后面的内容为日志内容
|
||
m1 = re.search(r'(.+)"\s*[,|)]', line)
|
||
if m1 is not None:
|
||
g_fsm_status = "LOG_EXIT_FINDING"
|
||
if "LOG_ENTRY_FOUNDED" == g_fsm_status:
|
||
m3 = re.search(r"\)[\s]*\;", line.strip())
|
||
if m3 is not None:
|
||
g_fsm_status = "LOG_ENTRY_FINDING"
|
||
g_log_entry_or_end_flag = -1
|
||
g_audio_log_key_index = -1
|
||
if g_log_str_full.find(line) == -1:
|
||
g_log_str_full += line
|
||
|
||
# 匹配部分日志接口
|
||
elif "LOG_CONT_END_FINDING" == g_fsm_status:
|
||
m = re.search(r"[\s]+(.+)\"", line)
|
||
if m is not None:
|
||
temp = m.groups()[0]
|
||
m1 = re.search(r'(.+)"\s*[,|)]', line) #部分日志可以跨多行
|
||
if m1 is None:
|
||
g_log_str += temp
|
||
else:
|
||
g_log_str += (temp + '\0')
|
||
g_fsm_status = "LOG_EXIT_FINDING"
|
||
parse_log_from_line(line)
|
||
else:
|
||
g_log_str += line.strip() # 纯日志内容 ，继续找日志
|
||
if g_log_str_full.find(line) == -1:
|
||
g_log_str_full += line
|
||
|
||
# 匹配日志结束符
|
||
elif "LOG_EXIT_FINDING" == g_fsm_status:
|
||
m = re.search(r"\)[\s]*\;", line.strip())
|
||
if m is not None:
|
||
g_fsm_status = "LOG_ENTRY_FINDING" # 继续逐行扫描下一条日志入口
|
||
g_log_entry_or_end_flag = 1
|
||
if g_log_str_full.find(line) == -1:
|
||
g_log_str_full += line
|
||
|
||
|
||
g_file_id_dict = {} # file_id_str file_id_num
|
||
g_last_file_id_num = 0
|
||
g_moudle_id = {
|
||
'wifi' : 0,
|
||
'bt' : 1,
|
||
'gnss' :2,
|
||
'dsp' : 3,
|
||
'pf' : 4,
|
||
'media' : 5,
|
||
'nfc': 6,
|
||
'app' : 7,
|
||
'gpu': 8,
|
||
'gui' : 9,
|
||
'slp' : 10,
|
||
'bth' : 11,
|
||
'ohos' : 12,
|
||
}
|
||
|
||
def parse_single_source_file(cfilepath, auto_def, module_name):
|
||
global g_log_key_find
|
||
global g_log_str
|
||
global g_fsm_status
|
||
global log_info_list
|
||
global g_audio_log_key_index
|
||
curr_line_num = 0 # 当前行行号
|
||
file_id_num = 0 # 本文件号
|
||
line_num_save = 0
|
||
log_info_list = []
|
||
|
||
m = re.search(r"\w.[cC|hH]", cfilepath)
|
||
if m is None:
|
||
print("Error!%s is not C or H File" % cfilepath)
|
||
return
|
||
|
||
# 增加对文件中换行符的处理
|
||
destfile = cfilepath + "_temp"
|
||
modify_newline_on_linux(cfilepath, destfile)
|
||
# 打开源文件，读取文件内容
|
||
try:
|
||
if py_version.startswith("3"):
|
||
try:
|
||
with open(destfile, 'r', encoding="UTF-8") as fd_src:
|
||
datalines = [line for line in fd_src]
|
||
except Exception:
|
||
with open(destfile, 'r', encoding="ISO-8859-1") as fd_src:
|
||
datalines = [line for line in fd_src]
|
||
else:
|
||
with open(destfile, 'r') as fd_src:
|
||
datalines = [line for line in fd_src]
|
||
except Exception:
|
||
print("open file %s failed." % cfilepath)
|
||
return
|
||
|
||
os.remove(destfile)
|
||
if module_name not in g_file_id_dict:
|
||
return
|
||
_, filename = os.path.split(cfilepath)
|
||
if auto_def:
|
||
file_id_str = filename.replace('.' , '_').upper()
|
||
if file_id_str not in g_file_id_dict[module_name]:
|
||
return
|
||
g_fsm_status = "LOG_ENTRY_FINDING"
|
||
else:
|
||
m = re.search(r"#define[\s]+THIS_FILE_ID[\s]+([\w]*)", '\n'.join(datalines))
|
||
if m is None:
|
||
return 0
|
||
file_id_str = m.group(1)
|
||
g_fsm_status = "LOG_ENTRY_FINDING"
|
||
|
||
# 遍历行内容
|
||
for line in datalines:
|
||
# 行号加1
|
||
curr_line_num += 1
|
||
|
||
m = re.search(r'^\/\/', line.strip())
|
||
if m is not None:
|
||
continue
|
||
# 判断是否可识别的普通日志文件
|
||
parse_log_from_line(line)
|
||
if 1 == g_log_key_find:
|
||
try:
|
||
file_id_num = g_file_id_dict[module_name][file_id_str]
|
||
moudle_id_num = g_moudle_id[module_name]
|
||
except KeyError:
|
||
#print(
|
||
# "warning: Moudle:%s, %s not defined. fileName[%s]." %
|
||
# (moudle_name, file_id_str, filename))
|
||
g_undefine_id.append((file_id_str, filename))
|
||
break
|
||
g_log_key_find = 0
|
||
line_num_save = curr_line_num
|
||
# 解析日志，判断是否找到，如果找到写入文件
|
||
if 1 == g_log_entry_or_end_flag:
|
||
g_log_str = g_log_str.replace('\\r', "") # 清除\r，\n，空格
|
||
g_log_str = g_log_str.replace('\\n', "")
|
||
g_log_str = g_log_str.replace('\r', "") # 清除\r，\n，空格
|
||
g_log_str = g_log_str.replace('\n', "")
|
||
g_log_str = g_log_str.replace("\\", "")
|
||
g_log_str = g_log_str.replace('""', "")
|
||
g_log_str = g_log_str.replace("\000", "")
|
||
g_log_str.strip()
|
||
if (g_audio_log_key_index != -1):
|
||
level_num, level_str = get_audio_log_level(g_log_str_full)
|
||
else:
|
||
level_num, level_str = get_log_level(g_log_str_full)
|
||
data = { }
|
||
data["MOD_ID"] = moudle_id_num
|
||
data["FILE_ID"] = file_id_num
|
||
if (aich_name == "cortex_m7"):
|
||
data["LINE_NUM"] = line_num_save
|
||
else:
|
||
data["LINE_NUM"] = curr_line_num
|
||
data["FMT"] = g_log_str
|
||
data["LEVEL_NUM"] = level_num
|
||
data["LEVEL_STR"] = level_str
|
||
data["ARGS_COUNT"] = g_log_str.count("%")
|
||
data["FILE_NAME"] = cfilepath.split('/')[-1]
|
||
log_info_list.append(data)
|
||
g_log_key_find = 0
|
||
g_audio_log_key_index = -1
|
||
return 0
|
||
|
||
|
||
# 保存FILD_ID
|
||
def save_file_id_dict(line_str, moudle_name):
|
||
global g_file_id_dict
|
||
global g_last_file_id_num
|
||
|
||
file_id_str = ''
|
||
file_id_num = 0
|
||
if line_str == '':
|
||
return 0
|
||
|
||
m2 = re.search("[^A-Za-z0-9_=]", line_str)
|
||
if m2 is None:
|
||
m1 = line_str.split('=') # XXXXXXX = dddd,
|
||
if len(m1) == 2:
|
||
file_id_str = m1[0] # 获取file id字符串
|
||
file_id_num = m1[1]
|
||
g_file_id_dict[moudle_name][file_id_str] = int(file_id_num)
|
||
g_last_file_id_num = int(file_id_num) + 1
|
||
else:
|
||
file_id_str = line_str
|
||
g_file_id_dict[moudle_name][file_id_str] = g_last_file_id_num
|
||
g_last_file_id_num += 1
|
||
else:
|
||
return -1
|
||
return 0
|
||
|
||
|
||
# 打印fileid的映射字典
|
||
def print_file_id_dict():
|
||
print(timestamp() + " start to print FileIdDict::")
|
||
for system_name in g_file_id_dict:
|
||
for key in g_file_id_dict[system_name]:
|
||
print(timestamp() + " key:%s value:%d" % (key,\
|
||
g_file_id_dict[system_name][key]))
|
||
|
||
|
||
# 获取FILE_ID枚举值
|
||
def get_file_id_enum_in_file(h_file_path):
|
||
global g_file_id_dict
|
||
global g_last_file_id_num
|
||
g_last_file_id_num = 0
|
||
|
||
moudle_name = os.path.basename(h_file_path).split('_')[-1][:-2]
|
||
# btc将file_id头文件迁移后取名为log_def_btc.h 实际moudle_name任是bt
|
||
# bth将file_id头文件迁移后取名为log_def_bth.h 实际moudle_name任是bt
|
||
if moudle_name == 'btc':
|
||
moudle_name = 'bt'
|
||
if chip == 'bs25' and core_name == 'bt_core' and moudle_name == "bth":
|
||
moudle_name = 'bt'
|
||
if moudle_name not in g_file_id_dict:
|
||
g_file_id_dict[moudle_name] = {}
|
||
m = re.search(r'\w+\.h$', h_file_path)
|
||
if m is None:
|
||
print(timestamp() + ' Wrong type file, please input head file path.')
|
||
return -1
|
||
|
||
if not os.path.exists(h_file_path):
|
||
print(timestamp() + ' Head file [%s] did not exist.' % (h_file_path))
|
||
return 0
|
||
try:
|
||
if py_version.startswith("3"):
|
||
with open(h_file_path, 'r', encoding="UTF-8") as fd:
|
||
id_file = fd.read()
|
||
else:
|
||
with open(h_file_path, 'r') as fd:
|
||
id_file = fd.read()
|
||
except Exception as e:
|
||
print(e)
|
||
return -1
|
||
id_list = re.search(r"typedef enum[\s]*\{([\d\D]*?)\}", id_file).group(1)
|
||
id_list = id_list.replace(',', '').replace(' ', '').split('\n')
|
||
for line_str in id_list:
|
||
line_str = line_str.strip().split("/")[0]
|
||
save_file_id_dict(line_str, moudle_name)
|
||
|
||
return 0
|
||
|
||
def get_file_id_enum_in_paths(h_file_paths):
|
||
for h_file in h_file_paths:
|
||
if not h_file:
|
||
continue
|
||
if get_file_id_enum_in_file(h_file) != 0:
|
||
return -1
|
||
return 0
|
||
|
||
|
||
# 文件换行符处理
|
||
def modify_newline_on_linux(srcfile, destfile):
|
||
with open(srcfile, "rb") as fsrc, open(destfile, "wb") as fdest:
|
||
while True:
|
||
cs = fsrc.read(1)
|
||
if len(cs) > 0:
|
||
if cs == "\r":
|
||
fdest.write(cs)
|
||
cs = fsrc.read(1)
|
||
if cs != "\n":
|
||
fdest.write("\n")
|
||
fdest.write(cs)
|
||
else:
|
||
fdest.write(cs)
|
||
else:
|
||
fdest.write(cs)
|
||
else:
|
||
break
|
||
|
||
#mkdir ${target} ${root} ${chip} ${core}
|
||
def generate_db_temp_dir(sys_argv):
|
||
root = sys_argv[2]
|
||
chip = sys_argv[3]
|
||
core_name = sys_argv[4]
|
||
in_path = XML_PATH
|
||
in_path = in_path.replace('<chip>', chip)
|
||
|
||
# get global settings
|
||
db_conf = None
|
||
conf = os.path.join(root, in_path)
|
||
with open(conf, 'r') as f:
|
||
db_conf = json.load(f)
|
||
|
||
base_file_dir = os.path.join(os.path.join(root, db_conf["HDB_XML_TEMP_BASE_DIR"]), core_name)
|
||
if not os.path.exists(base_file_dir):
|
||
os.makedirs(base_file_dir)
|
||
|
||
#${target} ${root} ${chip} ${core} ${src_file} ${file_id_dir}
|
||
def generate_db_xml(root, core_name, auto_def, module_name, src_file, closed_flag):
|
||
global log_info_list
|
||
if not os.path.isfile(src_file):
|
||
return
|
||
|
||
# get global settings
|
||
db_conf = None
|
||
conf = os.path.join(root, in_path)
|
||
with open(conf, 'r') as f:
|
||
db_conf = json.load(f)
|
||
|
||
parse_single_source_file(src_file, auto_def, module_name)
|
||
if len(log_info_list) == 0:
|
||
return
|
||
|
||
_, filename = os.path.split(src_file)
|
||
filename = filename + ".xml"
|
||
if (closed_flag != True):
|
||
base_file_dir = os.path.join(os.path.join(root, db_conf["HDB_XML_TEMP_BASE_DIR"]), core_name)
|
||
else:
|
||
base_file_dir = os.path.join(os.path.join(root, db_conf["HDB_XML_TEMP_BASE_DIR"]), "closed_comp")
|
||
if not os.path.exists(base_file_dir):
|
||
os.makedirs(base_file_dir)
|
||
|
||
dst_xml_full_name = os.path.join(base_file_dir, filename)
|
||
|
||
msg_root_element = ET.Element('MSG_LOG')
|
||
for data in log_info_list:
|
||
add_content_to_xml(data, msg_root_element)
|
||
|
||
tree = ET.ElementTree(msg_root_element)
|
||
tree.write(dst_xml_full_name)
|
||
|
||
# main
|
||
if __name__ == "__main__":
|
||
if (sys.argv[1] == "mkdir"):
|
||
generate_db_temp_dir(sys.argv)
|
||
sys.exit(0)
|
||
root = sys.argv[1]
|
||
chip = sys.argv[2]
|
||
core_name = sys.argv[3]
|
||
aich_name = sys.argv[4]
|
||
in_path = XML_PATH
|
||
in_path = in_path.replace('<chip>', chip)
|
||
auto_def = sys.argv[5]
|
||
if auto_def == "TRUE" or auto_def == "True":
|
||
auto_def = True
|
||
else:
|
||
auto_def = False
|
||
module_name = sys.argv[6]
|
||
closed_flag = sys.argv[7]
|
||
if closed_flag == "TRUE" or closed_flag == "True":
|
||
closed_flag = True
|
||
else:
|
||
closed_flag = False
|
||
info_file = sys.argv[8]
|
||
|
||
try:
|
||
with open(info_file, 'r') as f:
|
||
text = f.read()
|
||
file_id_dir = text.split("####")[0].split(',')
|
||
src_files = text.split("####")[1].split(',')
|
||
|
||
if file_id_dir != None and get_file_id_enum_in_paths(file_id_dir) != 0:
|
||
sys.exit(1)
|
||
|
||
for src_file in src_files:
|
||
src_file = src_file.strip()
|
||
generate_db_xml(root, core_name, auto_def, module_name, src_file, closed_flag)
|
||
except:
|
||
print("[WARN] open %s exception" % info_file)
|