#!/usr/bin/python3.8
"""
@file
mib_datapool_parser.py
@brief
Parses the global datapools and generates the corresponding source file optionally.
Python 3.8 required.
@details
Used by the MIB Exporter, inherits generic File Parser.
@author
R. Mueller
@date
03.01.2020
"""
import re
from enum import Enum
from datetime import date
from parserbase.mib_parser import FileParser
from utility.mib_csv_writer import CsvWriter
from utility.mib_printer import Printer
from utility.mib_file_management import copy_file
DATE_TODAY = date.today()
DATAPOOL_FILE = "../../config/dataPool/dataPoolInit.h"
DATAPOOL_CSV_NAME = "mib_datapool.csv"
CPP_FILE_NAME = "dataPoolInit.cpp"
WRITE_CSV_FILE = True
COPY_CSV_FILE = True
WRITE_CPP_FILE = True
COPY_CPP_FILE = False
CPP_COPY_DESTINATION = "../../config/dataPool/"
DATAPOOL_HEADER_COLUMNS = ["Pool ID", "Group", "Name", "Code Name", "Size", "Type", "Unit"]
class DatapoolColumns(Enum):
"""
Specifies order of MIB columns
"""
POOL_ID = 0
GROUP = 1
NAME = 2
CODE_NAME = 3
SIZE = 4
TYPE = 5
UNIT = 6
Clmns = DatapoolColumns
def main():
"""
This main is run if the datapool parser is to be run separately.
:return:
"""
file_list = [DATAPOOL_FILE]
print("DatapoolParser: Parsing datapool header file:")
print(file_list[0])
datapool_parser = DatapoolParser(file_list)
datapool_table = datapool_parser.parse_files()
Printer.print_content(datapool_table, "DatapoolParser: Printing datapool variable table:")
dh_command_writer = CsvWriter(DATAPOOL_CSV_NAME, datapool_table, DATAPOOL_HEADER_COLUMNS)
if WRITE_CSV_FILE:
dh_command_writer.write_to_csv()
if COPY_CSV_FILE:
dh_command_writer.move_csv("..")
if WRITE_CPP_FILE:
datapool_parser.write_data_pool_init_cpp()
print("DatapoolParser: C++ File was created.")
if COPY_CPP_FILE:
copy_file(CPP_FILE_NAME, CPP_COPY_DESTINATION)
print("DatapoolParser: Generated C++ file was copied to " + CPP_COPY_DESTINATION)
class DatapoolParser(FileParser):
"""
This parser reads the central datapool header file.
It can optionally generate the corresponding source file (C++11 needed).
Instantiate the class by supplying a number of files to parse and call the parse_files() method
:return:
"""
def __init__(self, file_list):
super().__init__(file_list)
# this table includes the current new table entry,
# which will be updated for target parameter
self.dict_entry_list = list(range(Clmns.__len__()))
self.cpp_file_information_list = []
self.parse_success = False
self.parse_for_datapool_entries = False
self.prev_group = ""
def _handle_file_parsing(self, file_name: str, *args, **kwargs):
file = open(file_name, "r")
print("Parsing " + file_name + " ...")
linecount = 1
for line in file.readlines():
self.__handle_line_reading(line)
linecount = linecount + 1
def _post_parsing_operation(self):
if len(self.mib_table) > 0:
self.parse_success = True
def write_data_pool_init_cpp(self):
"""
Writes the data pool CPP source file if the parsing was successfull
:param copy_cpp:
:param cpp_file_name:
:param cpp_copy_destination:
:return:
"""
if not self.parse_success:
print("Datapool Parser: MIB Table is empty, no data to write CPP file")
return
cpp_file = open(CPP_FILE_NAME, "w")
current_date = DATE_TODAY.strftime("%d.%m.%Y")
header = "/**\n * @file\tdataPoolInit.cpp\n *\n * @brief\tAuto-Generated datapool " \
"initialization\n * @date\t" + current_date +\
"\n */\n#include <config/dataPool/dataPoolInit.h> " \
"\n\nvoid datapool::dataPoolInit(poolMap * poolMap) {\n"
cpp_file.write(header)
entries_len = self.index + 1
for index in range(1, entries_len):
self.__handle_entry_write(cpp_file, index)
tail = "\n}\n"
cpp_file.write(tail)
cpp_file.close()
def __handle_line_reading(self, line):
if self.parse_for_datapool_entries:
if not self.__scan_for_pool_variable(line):
self.__scan_for_export_string(line)
if not self.parse_for_datapool_entries:
datapool_start = re.search(r'[\s]*enum[\w_ ]*[\s]*{', line)
if datapool_start:
self.parse_for_datapool_entries = True
else:
self.__scan_for_datapool_end(line)
def __scan_for_export_string(self, line):
export_string_match = re.search(r'[/*!>< ]*\[EXPORT\][ :]*([^\n]*)', line, re.IGNORECASE)
if export_string_match:
self.__handle_export_string_match(export_string_match.group(1))
return export_string_match
def __handle_export_string_match(self, string):
group_match = re.search(r'\[GROUP\][\s]*([^\n\*]*)', string, re.IGNORECASE)
if group_match:
self.dict_entry_list[Clmns.GROUP.value] = group_match.group(1).rstrip()
def __scan_for_pool_variable(self, line):
pool_var_match = re.search(r'[\s]*([\w]*)[ =]*([\w]*)(?:,)?[\s]*([^\n]*)', line)
if pool_var_match:
if pool_var_match.group(1) == "":
return False
self.__handle_pool_var_match(pool_var_match)
return pool_var_match
def __handle_pool_var_match(self, pool_var_match):
if re.search(r'NO_PARAMETER', pool_var_match.group(0)):
return
self.dict_entry_list[Clmns.CODE_NAME.value] = pool_var_match.group(1)
self.dict_entry_list[Clmns.POOL_ID.value] = pool_var_match.group(2)
export_string_match = re.search(r'[/!< ]*\[EXPORT\][: ]*([^\n]*)',
pool_var_match.group(3), re.IGNORECASE)
if export_string_match:
self.__handle_pool_var_export_string(export_string_match.group(1))
datapool_tuple = tuple(self.dict_entry_list)
self.index = self.index + 1
self.mib_table.update({self.index: datapool_tuple})
self.dict_entry_list[Clmns.SIZE.value] = ""
self.dict_entry_list[Clmns.TYPE.value] = ""
self.dict_entry_list[Clmns.NAME.value] = ""
self.dict_entry_list[Clmns.UNIT.value] = ""
def __handle_pool_var_export_string(self, string):
extracted_entries = re.findall(r'(?:\[([\w]*)\][\s]*([^\[]*))?', string)
if extracted_entries:
extraced_entries_len = len(extracted_entries) - 1
for group_index in range(extraced_entries_len):
(group_name, group_content) = extracted_entries[group_index]
group_content = group_content.rstrip()
if group_name.casefold() == "name":
self.dict_entry_list[Clmns.NAME.value] = group_content
elif group_name.casefold() == "size":
self.dict_entry_list[Clmns.SIZE.value] = group_content
elif group_name.casefold() == "type":
self.dict_entry_list[Clmns.TYPE.value] = group_content
elif group_name.casefold() == "unit":
self.dict_entry_list[Clmns.UNIT.value] = group_content
def __scan_for_datapool_end(self, line):
datapool_end = re.search(r'}[\s]*;', line)
if datapool_end:
self.parse_for_datapool_entries = False
def __handle_entry_write(self, cpp_file, index):
current_mib_entry = self.mib_table.get(index)
(_, current_group, _, current_code_name,
current_size, current_type, _) = current_mib_entry
if current_group != self.prev_group:
cpp_file.write("\n\t/* " + current_group + " */\n")
self.prev_group = current_group
current_pool_entry_init_value = "{"
if current_size == "":
print("Size is unknown for a pool entry. Please specify in header file !")
return
current_size = int(current_size)
for count in range(current_size):
current_pool_entry_init_value = current_pool_entry_init_value + "0"
if count != current_size - 1:
current_pool_entry_init_value = current_pool_entry_init_value + ", "
current_pool_entry_init_value = current_pool_entry_init_value + "}"
entry_string = "\tpoolMap->emplace(datapool::" + current_code_name + \
",\n\t\t\tnew PoolEntry<" + current_type + ">(" + \
current_pool_entry_init_value + "," + str(current_size) + "));\n"
cpp_file.write(entry_string)
if __name__ == "__main__":
main()