Init commit

generators/parserbase/mib_file_list_parser.py

@@ -0,0 +1,71 @@
+"""
+@file   mib_file_list_parser.py
+@brief  Generic File Parser class
+@details
+Used by parse header files. Implemented as class in case header parser becomes more complex
+@author R. Mueller
+@date   22.11.2019
+"""
+import os
+import re
+from typing import Union
+
+
+# pylint: disable=too-few-public-methods
+class FileListParser:
+    """
+    Generic header parser which takes a directory name or directory name list
+    and parses all included header files recursively.
+    """
+    def __init__(self, directory_list_or_name: Union[str, list]):
+        if isinstance(directory_list_or_name, str):
+            self.directory_list = [directory_list_or_name]
+        elif isinstance(directory_list_or_name, list):
+            self.directory_list = directory_list_or_name
+        else:
+            print("Header Parser: Passed directory list is not a header name or list of "
+                  "header names")
+        self.header_files = []
+
+    def parse_header_files(self, search_recursively: bool = False,
+                           printout_string: str = "Parsing header files: ",
+                           print_current_dir: bool = False):
+        """
+        This function is called to get a list of header files
+        :param search_recursively:
+        :param printout_string:
+        :param print_current_dir:
+        :return:
+        """
+        print(printout_string, end="")
+        for directory in self.directory_list:
+            self.__get_header_file_list(directory, search_recursively, print_current_dir)
+        print(str(len(self.header_files)) + " header files were found.")
+        # g.PP.pprint(self.header_files)
+        return self.header_files
+
+    def __get_header_file_list(self, base_directory: str, seach_recursively: bool = False,
+                               print_current_dir: bool = False):
+        if base_directory[-1] != '/':
+            base_directory += '/'
+        local_header_files = []
+        if print_current_dir:
+            print("Parsing header files in: " + base_directory)
+        base_list = os.listdir(base_directory)
+        # g.PP.pprint(base_list)
+        for entry in base_list:
+            header_file_match = re.match(r"[_.]*.*\.h", entry)
+            if header_file_match:
+                if os.path.isfile(base_directory + entry):
+                    match_string = header_file_match.group(0)
+                    if match_string[0] == '.' or match_string[0] == '_':
+                        pass
+                    else:
+                        local_header_files.append(base_directory + entry)
+            if seach_recursively:
+                next_path = base_directory + entry
+                if os.path.isdir(next_path):
+                    self.__get_header_file_list(next_path, seach_recursively)
+        # print("Files found in: " + base_directory)
+        # g.PP.pprint(local_header_files)
+        self.header_files.extend(local_header_files)

generators/parserbase/mib_parser.py

@@ -0,0 +1,71 @@
+#! /usr/bin/python3.7
+"""
+@file
+    mib_packet_content_parser.py
+@brief
+    Generic File Parser class
+@details
+    Used by the MIB Exporter. There are two functions which can be implemented by child class.
+    Default implementations are empty
+
+        1. handleFileParsing(...) which handles the parsing of one file
+        2. updateTableEntries(...) After all files have been parsed, the table can
+           be updated by imlementing this function
+
+    A file list to parse must be supplied.
+    Child classes fill out the MIB table (self.mib_table)
+@author
+    R. Mueller
+@date
+    14.11.2019
+"""
+from abc import abstractmethod
+from typing import Dict
+
+
+class FileParser:
+    """
+    This parent class gathers common file parser operations into a super class.
+    Everything else needs to be implemented by child classes
+    (e.g. which strings to parse for or operations to take after file parsing has finished)
+    """
+    def __init__(self, file_list):
+        if len(file_list) == 0:
+            print("File list is empty !")
+            self.file_list_empty = True
+        else:
+            self.file_list_empty = False
+        self.file_list = file_list
+        # Can be used to have unique key in MIB tables
+        self.index = 0
+        # Initialize empty MIB table which will be filled by specific parser implementation
+        self.mib_table = dict()
+
+    def parse_files(self, *args: any, **kwargs) -> Dict:
+        """
+        Core method which is called to parse the files
+        :param args: Optional positional arguments. Passed on the file parser
+        :param kwargs: Optional keyword arguments. Passed on to file parser
+        :return:
+        """
+        if not self.file_list_empty:
+            for file_name in self.file_list:
+                # Implemented by child class ! Fill out info table (self.mib_table) in this routine
+                self._handle_file_parsing(file_name, *args, **kwargs)
+            # Can be implemented by child class to edit the table after it is finished.
+            # default implementation is empty
+            self._post_parsing_operation()
+        return self.mib_table
+
+    # Implemented by child class ! Fill out info table (self.mib_table) in this routine
+    @abstractmethod
+    def _handle_file_parsing(self, file_name: str, *args, **kwargs):
+        pass
+
+    @abstractmethod
+    def _post_parsing_operation(self):
+        """
+        # Can be implemented by child class to perform post parsing operations (e.g. setting a
+        flag or editting MIB table entries)
+        :return:
+        """