#!/usr/bin/env python3 ############################################################################## ## Copyright (C) 2022-2023 Analog Devices, Inc. All rights reserved. ### SPDX short identifier: ADIBSD # ## Check readme_check_guideline.md from the same folder, for more details. ############################################################################## import os import re import codecs import sys from datetime import datetime ############################################################################## # # Class definitions ############################################################################## class Port (object): def __init__ (self, name="unknown", direction="unknown", ptype="wire"): self.name = name self.direction = direction self.ptype = ptype class Occurrence (object): # path - to the file where the occurrence was found # line - where the instantiated module is # line_end - where the instantiated module ends # pos_start_ports - how many lines after .line the ports list starts, inside # the instantiated module def __init__ (self, path="unknown", line="unknown"): self.path = path self.line = line self.line_end = -1 self.pos_start_ports = -1 class Interface (object): def __init__ (self): self.interface = [] def add_port (self, port): self.interface.append(port) ############################################################################## # # Functions ############################################################################## def is_comment (line): rcoma = re.compile(r'^\s*//') rcomb = re.compile(r'^\s*/\*') if (rcoma.match(line) or rcomb.match(line)): return True else: return False def is_multiline_comment (line): if ((line.strip()).startswith("*")): return True else: if ((line.find("/*") != -1) or (line.find("*/") != -1)): return True else: return False def is_paramdef (line): rparameter = re.compile(r'^\s*parameter\s.*') if (rparameter.match(line)): return True else: return False def is_iodef (line): rinput = re.compile(r'^\s*input\s.*') routput= re.compile(r'^\s*output\s.*') rinout = re.compile(r'^\s*inout\s.*') if ((rinput.match(line)) or (routput.match(line)) or (rinout.match(line))): return True else: return False # check if the given string is made only of spaces or tabs def only_spaces_or_tabs (substr): substr = substr.strip() substr = substr.strip("\t") if (substr == ""): return True else: return False # check if one of the modified files appears in the warning message def list_has_substring (modified_files, message): for mfile in modified_files: if (message.find(mfile) != -1): return True return False # check if file is between the modified files specified as arguments def string_in_list (module_path, modified_files): for mfile_path in modified_files: if (("./" + mfile_path) == module_path or mfile_path == module_path): return True return False ############################################################################### # # Check if file has correct properties, meaning that the file extension has to # be .v and it should not be some certain files (.sv, tb) # Returns true or false. ############################################################################### def check_filename (filename): if (filename.endswith('.v') == False): return False if (filename.endswith('.sv') == True): return False if (filename.find("tb") != -1): return False return True ############################################################################### # # Detect all modules present in the given directory in /library and /projects. # Return a list with the relative paths. ############################################################################### def detect_all_modules (directory): detected_modules_list = [] for folder, dirs, files in os.walk(directory): ## folder name must be either library or projects, ## and it must not contain a dot in the name (Vivado generated) if ((folder[1:-2]).find(".") == -1 and (folder.find("library") != -1 or folder.find("projects") != -1)): for file in files: #filename_wout_ext = (os.path.splitext(file)[0]) if (check_filename(file)): fullpath = os.path.join(folder, file) detected_modules_list.append(fullpath) return detected_modules_list ############################################################################### # # Determine the file name from the fullpath. # Return the string containing the file name without extension. ############################################################################### def get_file_name (module_path): # split the path using the / and take the last group, which is the file.ext split_path = module_path.split("/") module_filename = split_path[len(split_path) - 1] # take the module name from the filename with the extension filename_wout_ext = module_filename.split(".")[0] return filename_wout_ext ############################################################################### # # Check if there are lines after `endmodule and two consecutive empty lines, # and if there are and edit_files is true, delete them. ############################################################################### def check_extra_lines (module_path, list_of_lines, lw, edit_files): passed_endmodule = False line_nb = 1 prev_line = "" remove_end_lines = False if (edit_files): remove_extra_lines = False for line in list_of_lines: # GC: check for lines after endmodule if (line.find("endmodule") != -1): passed_endmodule = True # if we passed the endmodule tag if (passed_endmodule and (line.find("endmodule") == -1)): remove_end_lines = True # GC: check for empty lines if (line_nb >= 2): if (only_spaces_or_tabs(prev_line) and only_spaces_or_tabs(line) and (not is_comment(prev_line)) and (not is_comment(line))): lw.append(module_path + " : " + str(line_nb) + " two or more consecutive empty lines") if (edit_files): remove_extra_lines = True line_nb += 1 if (line_nb >= 2): prev_line = line if (remove_end_lines): if (edit_files): deleted_lines = False passed_endmodule = False line_nb = 1 while (line_nb <= len(list_of_lines)): line = list_of_lines[line_nb-1] if (line.find("endmodule") != -1): passed_endmodule = True if (not (passed_endmodule and (line.find("endmodule") == -1))): line_nb += 1 else: deleted_lines = True list_of_lines.pop(line_nb-1) if (deleted_lines): lw.append(module_path + " : deleted lines after endmodule") else: lw.append(module_path + " : couldn't delete lines after endmodule but must!") else: lw.append(module_path + " : extra lines after endmodule") if (edit_files and remove_extra_lines): line_nb = 1 prev_line = "" while (line_nb <= len(list_of_lines)): line = list_of_lines[line_nb-1] if (line_nb >= 2): if (only_spaces_or_tabs(prev_line) and only_spaces_or_tabs(line) and (not is_comment(prev_line)) and (not is_comment(line))): lw.append(module_path + " : " + str(line_nb) + " removed consecutive empty lines") list_of_lines.pop(line_nb-1) else: line_nb += 1 else: line_nb += 1 if (line_nb >= 2): prev_line = line ############################################################################### # Get the nth digit from a number. # The numbering in this scheme uses zero-indexing and starts from the right side # of the number. # The // performs integer division by a power of ten to move the digit to the # ones position, then the % gets the remainder after division by 10. ############################################################################### def get_digit (number, n): return number // 10**n % 10 ############################################################################### # # List of files that strings that the module path must not contain, in order to # check for the license header. ############################################################################### avoid_list = [] #avoid_list.append("jesd") avoid_list.append("fir_interp") avoid_list.append("cic_interp") def header_check_allowed (module_path): for str in avoid_list: if (module_path.find(str) != -1): return False return True ############################################################################### # # Check if the license header is written correctly, meaning: # To have either a range of years from the first time it was committed and # until the current year # or just the current year, if this is the first commit. ############################################################################### def check_copyright (list_of_lines, lw, edit_files): currentYear = datetime.now().year # license_header = """// *************************************************************************** #// *************************************************************************** #// Copyright (C) """ + str(currentYear) + """ Analog Devices, Inc. All rights reserved. #// #// In this HDL repository, there are many different and unique modules, consisting #// of various HDL (Verilog or VHDL) components. The individual modules are #// developed independently, and may be accompanied by separate and unique license #// terms. #// #// The user should read each of these license terms, and understand the #// freedoms and responsibilities that he or she has by using this source/core. #// #// This core is distributed in the hope that it will be useful, but WITHOUT ANY #// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR #// A PARTICULAR PURPOSE. #// #// Redistribution and use of source or resulting binaries, with or without modification #// of this file, are permitted under one of the following two license terms: #// #// 1. The GNU General Public License version 2 as published by the #// Free Software Foundation, which can be found in the top level directory #// of this repository (LICENSE_GPL2), and also online at: #// #// #// OR #// #// 2. An ADI specific BSD license, which can be found in the top level directory #// of this repository (LICENSE_ADIBSD), and also on-line at: #// https://github.com/analogdevicesinc/hdl/blob/master/LICENSE_ADIBSD #// This will allow to generate bit files and not release the source code, #// as long as it attaches to an ADI device. #// #// *************************************************************************** #// ***************************************************************************""" changed = False template_matches = True header_status = -1 # for further development, if the entire license should be checked # number of lines for the license header text, including the last line #lh_nb = license_header.count('\n') + 1 # if this is the line with the Copyright year line_nb = 2 ## from [17-25] is the range of years ## [17-20] is the beginning year ## [21] is the dash [-] ## [22-25] is the last year aux = list(list_of_lines[line_nb]) # match a year range match = re.match(r'.*(Copyright\s\(C\)\s20[0-9]{2}[-]20[0-9]{2})', list_of_lines[line_nb]) if (match is not None): # only the last year must be updated (chars [22-25]) c1 = str(get_digit(currentYear, 3)) c2 = str(get_digit(currentYear, 2)) c3 = str(get_digit(currentYear, 1)) c4 = str(get_digit(currentYear, 0)) # if already set to current year, then no edits and no warnings if (aux[22] == c1 and aux[23] == c2 and aux[24] == c3 and aux[25] == c4): changed = False else: aux[22] = c1 aux[23] = c2 aux[24] = c3 aux[25] = c4 #list_of_lines[line_nb] = "// Copyright (C) " + list_of_lines[line_nb][17] + list_of_lines[line_nb][18] + list_of_lines[line_nb][19] + list_of_lines[line_nb][20] + "-" + str(currentYear) + " Analog Devices, Inc. All rights reserved.\n" changed = True else: # match a single year match = re.match(r'.*(Copyright\s\(C\)\s20[0-9]{2})', list_of_lines[line_nb]) if (match is not None): ## if the year is different than the currentYear, ## then must make a year range [17-25] year = aux[17] + aux[18] + aux[19] + aux[20] if (year != str(currentYear)): aux.insert(21, '-') aux.insert(22, str(get_digit(currentYear, 3))) aux.insert(23, str(get_digit(currentYear, 2))) aux.insert(24, str(get_digit(currentYear, 1))) aux.insert(25, str(get_digit(currentYear, 0))) #list_of_lines[line_nb] = "// Copyright (C) " + str(year) + "-" + str(currentYear) + " Analog Devices, Inc. All rights reserved.\n" changed = True else: changed = False else: # if none of the Copyright templates match template_matches = False # files can be changed and header got updated if (edit_files and changed and template_matches): list_of_lines[line_nb] = "".join(aux) lw.append(module_path + " : license header updated by the script") header_status = 1 # header up-to-date already and matches a template if (not changed and template_matches): header_status = 2 # files not to be edited and header is not up-to-date if (not edit_files and changed and template_matches): lw.append(module_path + " : license header cannot be updated") header_status = 3 # template doesn't match if (not template_matches): lw.append(module_path + " : copyright template doesn't match") header_status = 4 return header_status ############################################################################### # # Check for guideline rules applied to module definitions and the entire file, # except for the module instances. They are processed in check_guideline_instances. # This can modify the files if edit_files is true. # Return the string containing the module name and print errors for guideline # if it is not respected. ############################################################################### def get_and_check_module (module_path, lw, edit_files): lw_initial_size = len(lw) lw.append("\nAt module definition:") fp = open("%s" % (module_path), "r") list_of_lines = fp.readlines() fp.close() ## do not check the license status for the files that must be avoided, ## since it doesn't apply if (header_check_allowed(module_path)): header_status = check_copyright(list_of_lines, lw, edit_files) # GC: check if the license header is updated if (header_status == -1): edited = False lw.append(module_path + " : copyright text doesn't match the pattern for the Copyright year") else: header_status = -1 module_name = "" name_found = False params_exist = False end_line = -1 line_nb = 1 passed_module = False passed_endmodule = False last_iodef_line = -1 last_paramdef_line = -1 changed_line1 = -1 changed_line2 = -1 changed_line1_sit = -1 extra_chars = False for line in list_of_lines: pos_module = line.find("module") pos_endmodule = line.find("endmodule") pos_paranth1 = line.find("(") pos_comma = line.find(",") if (pos_module == 0): passed_module = True if (pos_endmodule != -1): passed_endmodule = True # GC: check for spaces at the end of line if (re.search(" +$", line) != None): extra_chars = True lw.append(module_path + " : " + str(line_nb) + " extra spaces at the end of line") # if the module declaration didn't end already if (is_paramdef(line) and passed_module and end_line == -1): if (pos_comma == -1): last_paramdef_line = line_nb else: pos_comment = line.find("/") ## if the first found comma is after a /, it means it's the ## last parameter line if (pos_comment > 0 and pos_comment < pos_comma): last_paramdef_line = line_nb # if the module declaration didn't end already if (is_iodef(line) and passed_module and end_line == -1): if (pos_comma == -1): last_iodef_line = line_nb else: pos_comment = line.find("/") ## if the first found comma is after a /, it means it's the ## last io line if (pos_comment > 0 and pos_comment < pos_comma): last_iodef_line = line_nb # if still inside the module declaration (with params) if (name_found and params_exist and end_line == -1): pos_paranth2 = line.find(")") if (0 <= pos_paranth2 and pos_paranth2 < pos_paranth1): if (re.search("\)\\s\(", line) != None): rest_of_line = line.strip().strip("(").strip().strip(")") ## GC: situations when the guideline is not respected: ## 1. | ) ( ## 2. |) ( something ## 3. | smth ) ( something ## 4. means it's one of the above if (pos_paranth2 > 0 or rest_of_line != ""): changed_line1_sit = 4 lw.append(module_path + " : " + str(line_nb) + " at ) ( not at the beginning of an empty line") if (edit_files): # situation 1: clear before ) ( if (pos_paranth2 > 0 and rest_of_line == ""): changed_line1_sit = 1 aux = list(list_of_lines[line_nb-1]) auxf = [")", " ", "("] l = 0 for c in aux: # remove the ), the space and the ( if (l != pos_paranth2 and (l != pos_paranth2 + 1) and l != pos_paranth1): auxf.append(c) l += 1 list_of_lines[line_nb-1] = "".join(auxf) changed_line1 = line_nb # situation 2: add a newline if (pos_paranth2 == 0 and rest_of_line != ""): changed_line1_sit = 2 aux = list(list_of_lines[line_nb-1]) auxf = [] l = 0 for c in aux: # remove the ), the space and the ( if (l != pos_paranth2 and (l != pos_paranth2 + 1) and l != pos_paranth1): auxf.append(c) l += 1 list_of_lines[line_nb-1] = "".join(auxf) changed_line1 = line_nb # situation 3: clear before ) ( and add a newline if (pos_paranth2 > 0 and rest_of_line != ""): changed_line1_sit = 3 aux = list(list_of_lines[line_nb-1]) auxf = [] l = 0 for c in aux: # remove the ), the space and the ( if (l != pos_paranth2 and (l != pos_paranth2 + 1) and l != pos_paranth1): auxf.append(c) l += 1 list_of_lines[line_nb-1] = "".join(auxf) changed_line1 = line_nb else: lw.append(module_path + " : " + str(line_nb) + " at ) ( has to have exactly 1 space between") # if still inside the module declaration and regardless of params if (name_found and end_line == -1): pos_closing = line.find(");") if (pos_closing >= 0): end_line = line_nb if ((last_iodef_line + 1 != line_nb) or (pos_closing >= 0)): rest_of_line = line.strip().strip(";").strip().strip(")") if (pos_closing > 0 or rest_of_line != ""): lw.append(module_path + " : " + str(line_nb) + " at ); not at the beginning of the next line after the last port") if (edit_files): if (pos_closing > 0 or rest_of_line != ""): aux = list(list_of_lines[line_nb-1]) auxf = [] l = 0 for c in aux: # remove the ) and ; if (l != pos_closing and (l != pos_closing + 1)): auxf.append(c) l += 1 list_of_lines[line_nb-1] = "".join(auxf) changed_line2 = line_nb # GC: check for indentation of the file ## if it's a regular line if ((pos_module == -1) and (pos_endmodule == -1) and (not only_spaces_or_tabs(line)) and (not is_comment(line)) and (not is_multiline_comment(line)) and passed_module and (not passed_endmodule) and (line.find("`") == -1)): indent_nb = len(line) - len(line.lstrip()) if (not (indent_nb >= 2)): if (line_nb != (last_paramdef_line+1) and line_nb != (last_iodef_line+1)): lw.append(module_path + " : " + str(line_nb) + " no indentation found") else: # take only iodef from modules and not from functions also if (indent_nb != 2 and is_paramdef(line)): lw.append(module_path + " : " + str(line_nb) + " indentation is not proper") # get the module name by reading the line that contains "module" # GC: check for proper positioning of the module declaration if ((not is_comment(line)) and (not name_found)): if (pos_module == 0): ## situations accepted ## 1. module module_name ( ## 2. module module_name #( pos_diez = line.find("#") # 2nd situation if (pos_diez > 0): if (pos_paranth1 == pos_diez + 1): module_name = re.search("module(.*?)#\(", line) if (module_name != None): module_name = module_name.group(1) module_name = module_name.strip() name_found = True else: lw.append(module_path + " : " + str(line_nb) + " at module name - error") else: lw.append(module_path + " : " + str(line_nb) + " at module #( guideline not respected") params_exist = True # 1st situation else: module_name = line.strip("module") module_name = module_name.strip() module_name = module_name.strip("\n") module_name = module_name.strip() module_name = module_name.strip("(") module_name = module_name.strip() name_found = True line_nb += 1 if (edit_files): if (changed_line1 != -1): if (changed_line1_sit == 2 or changed_line1_sit == 3): list_of_lines.insert(changed_line1, ") (\n") if (changed_line2 != -1): if (changed_line1 != -1 and changed_line1_sit > 1): changed_line2 += 1 last_iodef_line += 1 ## +1 -1 because we want on the next line after the last iodef line, ## but also the counting with line_nb starts from 1, and in ## files it starts from 0 list_of_lines.insert((last_iodef_line + 1) - 1, ");\n") # GC: check for lines after endmodule and empty lines # (and delete them, if desired) prev_length = len(list_of_lines) check_extra_lines (module_path, list_of_lines, lw, edit_files) if (edit_files): # if at least one of the things was edited if (changed_line1 != -1 or changed_line2 != -1 or extra_chars or prev_length != len(list_of_lines) or (header_status == 1)): # then rewrite the file with open(module_path, "w") as f: for line in list_of_lines: # GC: check for whitespace at the end of the line w\o \n aux_line = line[:-1] aux_line = aux_line.rstrip() f.write(aux_line + "\n") if (extra_chars): lw.append(module_path + " : removed extra spaces at the end of lines") if (not name_found): lw.append(module_path + " : module name couldn't be extracted\n") lw_last_size = len(lw) if (lw_last_size == lw_initial_size + 1): lw.pop() return module_name ############################################################################### # # Find all occurrences of the given module (path) in all files from the given # directory (recursively, but only in \library or \projects) or in all files # from list_of_files (if specified). # Return list of paths (for the occurrences) relative to the given directory. ############################################################################### def find_occurrences (directory, module_name, list_of_files): occurrences_list = [] for folder, dirs, files in os.walk(directory): ## only folder paths without a dot ## and to be either from /library or from /projects if (not ((folder[1:-2]).find(".") == -1 and (folder.find("library") != -1 or folder.find("projects") != -1))): continue for file in files: fullpath = os.path.join(folder, file) if (not check_filename(fullpath)): continue search = False if (list_of_files and (string_in_list(fullpath, list_of_files))): search = True elif (not list_of_files): search = True ## the file with the module definition is not accepted and ## neither the files that have to be avoided if (search and file != (module_name + ".v")): with codecs.open(fullpath, 'r', encoding='utf-8', errors='ignore') as f: line_nb = 1 for line in f: if ((line.find(module_name) != -1) and (not is_comment(line))): pos = line.find(module_name) pos_dot = line.find(".") # if there is no dot before the module name if (pos_dot == -1 or pos < pos_dot): if ((line[pos+len(module_name)] == ' ') or (line[pos+len(module_name)] == '#') or (line[pos+len(module_name)] == '(') or (line[pos+len(module_name)] == '\t')): # if before the instance name there are only spaces, then it is ok if (only_spaces_or_tabs(line[:pos-1]) == True): new_occurrence = Occurrence(path=fullpath, line=line_nb) ## check if it has a parameters list; ## then instance name is on the same line if ("#" not in line): new_occurrence.pos_start_ports = 0 occurrences_list.append(new_occurrence) line_nb += 1 return occurrences_list ############################################################################### # # Find the lines where an occurrence starts, ends and where its list of ports # starts. # Return nothing (the occurrence_item fields are directly modified) ############################################################################### def set_occurrence_lines (occurrence_item, list_of_lines): pos_start_module = -1 pos_end_module = -1 param_exist = False instance_lines = [] line_nb = 1 # find the start and the end line of the module instance for line in list_of_lines: if (pos_end_module == -1): if (occurrence_item.line == line_nb): pos_start_module = line_nb if ("#" in line): param_exist = True # if we are inside of the module instance if (pos_start_module != -1): if (line.find(");") != -1): pos_end_module = line_nb occurrence_item.line_end = pos_end_module else: break line_nb += 1 if (not param_exist): occurrence_item.pos_start_ports = 0 else: # with parameters: get the ports' list in all_inst_lines, including parameters all_inst_lines = "" line_nb = 1 for line in list_of_lines: if (pos_start_module <= line_nb and line_nb <= pos_end_module): all_inst_lines = all_inst_lines + line elif (line_nb > pos_end_module): break line_nb += 1 ## find the line where the instance name is; ## the ports should start from the next line, which is pos_start_ports+1 # find a string that is spread over multiple lines aux_instance_name = re.findall('\)\n(.*?)\(', all_inst_lines, re.M) # if )\n i_... ( if (len(aux_instance_name) > 0): instance_name = aux_instance_name[0].strip(" ") else: # if ) i_... ( instance_name = re.findall('\)(.*?)\(', all_inst_lines, re.M)[0].strip(" ") line_nb = 1 pos_start_ports = -1 # update occurrence_item.pos_start_ports if it wasn't already set for line in list_of_lines: if (pos_start_module <= line_nb and line_nb <= pos_end_module): if ((instance_name in line) and (pos_start_ports == -1)): # if not already specified in find_occurrences, without a parameters list if (occurrence_item.pos_start_ports == -1): pos_start_ports = line_nb - pos_start_module occurrence_item.pos_start_ports = pos_start_ports elif (line_nb > pos_end_module): break line_nb += 1 ############################################################################### # # Check for the guideline rules applied to the module instaces and output # warnings for each line, if any. ############################################################################### def check_guideline_instances (occurrence_item, lw): # list of warnings lw_initial_size = len(lw) lw.append("\nAt instances:") with open(occurrence_item.path, 'r') as in_file: list_of_lines = in_file.readlines() # have all the fields of the occurrence_item set_occurrence_lines(occurrence_item, list_of_lines) ## with parameters: get the module instance's lines in all_inst_lines, ## including the parameters all_inst_lines = "" line_nb = 1 for line in list_of_lines: if (occurrence_item.line <= line_nb and line_nb <= occurrence_item.line_end): all_inst_lines = all_inst_lines + line elif (line_nb > occurrence_item.line_end): break line_nb += 1 port_pos = 0 line_nb = 1 spaces_nb = -1 passed_module = False passed_endmodule = False for line in list_of_lines: inside_module_instance = False line_start_ports = occurrence_item.line + occurrence_item.pos_start_ports if ((occurrence_item.line <= line_nb) and (line_nb <= occurrence_item.line_end)): inside_module_instance = True # GC: indentation for the line where the instance name is if (line_start_ports == line_nb): spaces_nb = len(line) - len(line.lstrip()) if ((spaces_nb <= 0) or (spaces_nb % 2 != 0)): lw.append(occurrence_item.path + " : " + str(line_nb) + " wrong indentation at instance name") # GC: indentation for the line where the module name is if (occurrence_item.line == line_nb): start_spaces_nb = len(line) - len(line.lstrip()) if ((start_spaces_nb <= 0) or (start_spaces_nb % 2 != 0)): lw.append(occurrence_item.path + " : " + str(line_nb) + " wrong indentation at module name") # GC: check for proper positioning of the module instance if (inside_module_instance): if ("#" in line): diez_ok = False if ("." in line): lw.append(occurrence_item.path + " : " + str(line_nb) + " #(. in module instance") else: pos_diez = line.find("#") pos_paranth1 = line.find("(") pos_paranth2 = line.find(")") if ((0 < pos_diez) and (pos_diez + 1 == pos_paranth1) and (pos_paranth2 == -1)): diez_ok = True else: if (pos_paranth2 != -1): lw.append(occurrence_item.path + " : " + str(line_nb) + " parameters must be each on its own line") else: lw.append(occurrence_item.path + " : " + str(line_nb) + " parameters list is not written ok") # for the line where the instance name is # find a string like )\n ... ( aux_instance_name = re.findall('\)\n(.*?)\(', all_inst_lines, re.M) instance_name = "" # if )\n i_... ( if (len(aux_instance_name) > 0): instance_name = aux_instance_name[0].strip(" ") if (")" not in instance_name): lw.append(occurrence_item.path + " : " + str(line_start_ports) + " ) i_... ( instance name not written ok") else: try: # if ) i_... ( instance_name = re.findall('\)(.*?)\(', all_inst_lines, re.M)[0].strip(" ") except Exception: lw.append(occurrence_item.path + " : " + str(occurrence_item.line + occurrence_item.pos_start_ports) + " couldn't extract instance name") pos_dot = line.find(".") pos_comma = line.find(",") pos_closing = line.find(");") # GC: all ); of instances cannot be on an empty line aux_line = line.strip() aux_line = aux_line.strip("\t") aux_line = aux_line.strip(")") aux_line = aux_line.strip(";") if ((pos_closing != -1) and (only_spaces_or_tabs(aux_line))): lw.append(occurrence_item.path + " : " + str(line_nb) + " ); when closing module instance") # every dot starting from (.line + .pos_start_ports) line means a new port is declared if ((line_start_ports <= line_nb) and (pos_dot != -1)): port_indentation = len(line) - len(line.lstrip()) port_pos += 1 # 1. the first port in the module instance # 2. anywhere inside the instance, but not the first or last # 3. when .port()); # 4. last port when .port()\n and ); is on the next line # no situation or error situation situation = 0 inst_closed = False if (pos_closing != -1): inst_closed = True # 1st situation if (port_pos == 1): situation = 1 else: # 3rd situation if ((pos_dot != -1) and inst_closed): situation = 3 else: # 4th situation if ((pos_dot != -1) and (pos_comma == -1) and (not inst_closed)): situation = 4 else: # 2nd situation if ((pos_dot != -1) and (pos_comma != -1) and (not inst_closed)): situation = 2 else: lw.append(occurrence_item.path + " : " + str(line_nb) + " problem when finding the situation") if (situation != 0): # the rest of the ports must have the same indentation as the previous line if (port_indentation - spaces_nb != 2): avoid_indentation_check = False if ((line.find("({") != -1) or (line.find("})") != -1)): avoid_indentation_check = True if (not avoid_indentation_check): lw.append(occurrence_item.path + " : " + str(line_nb) + " indentation inside module instance") else: # if inside the parameters list if (occurrence_item.line <= line_nb and line_nb < line_start_ports and (pos_dot != -1)): param_indentation = len(line) - len(line.lstrip()) if (param_indentation - start_spaces_nb != 2): lw.append(occurrence_item.path + " : " + str(line_nb) + " indentation inside parameters list") line_nb += 1 if (line_nb > occurrence_item.line_end): break lw_last_size = len(lw) if (lw_last_size == lw_initial_size + 1): lw.pop() ############################################################################### # # Check guideline for Verilog files in repository ############################################################################### ## all files given as parameters to the script (or all files from repo ## if no flag is specified) modified_files = [] error_files = [] edit_files = False guideline_ok = True # detect all modules from current directory (hdl) all_modules = detect_all_modules("./") xilinx_modules = [] xilinx_modules.append("ALT_IOBUF") xilinx_modules.append("BUFG") xilinx_modules.append("BUFG_GT") xilinx_modules.append("BUFGCE") #xilinx_modules.append("BUFGCE_1") xilinx_modules.append("BUFGCE_DIV") xilinx_modules.append("BUFGCTRL") xilinx_modules.append("BUFGMUX") #xilinx_modules.append("BUFGMUX_1") xilinx_modules.append("BUFGMUX_CTRL") xilinx_modules.append("BUFIO") xilinx_modules.append("BUFR") xilinx_modules.append("GTHE3_CHANNEL") xilinx_modules.append("GTHE4_CHANNEL") xilinx_modules.append("GTYE4_CHANNEL") xilinx_modules.append("GTXE2_CHANNEL") xilinx_modules.append("IBUFDS") xilinx_modules.append("IBUFDS_GTE2") xilinx_modules.append("IBUFDS_GTE3") xilinx_modules.append("IBUFDS_GTE4") xilinx_modules.append("IBUFDS_GTE5") xilinx_modules.append("IBUFG") xilinx_modules.append("IDDR") xilinx_modules.append("IDELAYCTRL") xilinx_modules.append("ISERDESE2") xilinx_modules.append("OBUFDS") xilinx_modules.append("ODDR") xilinx_modules.append("system_bd") xilinx_modules.append("system_wrapper") # if there is an argument specified if (len(sys.argv) > 1): # -m means a file name/s will be specified (including extension!) # mostly used for testing manually, changing the folder_path # -me means that it will also modify the files if (sys.argv[1] == "-m" or sys.argv[1] == "-me"): if (sys.argv[1] == "-me"): edit_files = True arg_nb = 2 while (arg_nb < len(sys.argv)): # look in the folder_path = current folder for folder, dirs, files in os.walk("./"): for name in files: if((name == sys.argv[arg_nb]) and (check_filename(name))): #module_path = os.path.abspath(os.path.join(folder, sys.argv[arg_nb])) module_path = os.path.join(folder, sys.argv[arg_nb]) modified_files.append(module_path) arg_nb += 1 # -p means a path/s will be specified # mostly used for github action # -pe means that it will also modify the files if (sys.argv[1] == "-p" or sys.argv[1] == "-pe"): if (sys.argv[1] == "-pe"): edit_files = True arg_nb = 2 while (arg_nb < len(sys.argv)): if (os.path.exists(sys.argv[arg_nb])): if (check_filename(sys.argv[arg_nb])): modified_files.append(sys.argv[arg_nb]) else: error_files.append(sys.argv[arg_nb]) arg_nb += 1 # -e means it will be run on all files, making changes in them if (sys.argv[1] == "-e"): edit_files = True modified_files = detect_all_modules("./") else: ## if there is no argument then the script is run on all files, ## and without making changes in them edit_files = False modified_files = detect_all_modules("./") # no matter the number of arguments if (len(modified_files) <= 0): print("NO detected modules") guideline_ok = True sys.exit(0) else: for module_path in all_modules: module_name = get_file_name(module_path) # list of warnings lw = [] # if the detected module is between the modified files if (string_in_list(module_path, modified_files)): module_name = get_and_check_module(module_path, lw, edit_files) file_name = get_file_name(module_path) # file_name is without the known extension, which is .v if (module_name != file_name): # applies only to the library folder if (module_path.find("library") != -1): guideline_ok = False error_files.append(module_path) ## system_top modules won't be instantiated anywhere in other ## Verilog or SystemVerilog files if (module_path.find("system_top") == -1): # will search for instances only in the files given as arguments occurrences_list = find_occurrences("./", module_name, modified_files) if (len(occurrences_list) > 0): for occurrence_item in occurrences_list: check_guideline_instances(occurrence_item, lw) if (len(lw) > 0): guideline_ok = False print ("\n -> For %s in:" % module_path) for message in lw: print(message) for module_name in xilinx_modules: lw = [] xilinx_occ_list = find_occurrences("./", module_name, modified_files) if (len(xilinx_occ_list) > 0): for xilinx_occ_it in xilinx_occ_list: # if the xilinx module was found in the files that are of interest for it in all_modules: if (xilinx_occ_it.path == it): # only then to check the guideline check_guideline_instances(xilinx_occ_it, lw) if (len(lw) > 0): title_printed = False for message in lw: if (list_has_substring(modified_files, message)): if (not title_printed): print ("\n -> For %s in:" % module_name) title_printed = True guideline_ok = False print(message) if (error_files): error_in_library = False for file in error_files: ## for files in /projects folder, ## the module - file name check doesn't matter if (file.find("library") != -1): error_in_library = True if (error_in_library): guideline_ok = False print ("Files with name errors:") for file in error_files: ## for files in /projects folder, ## the module - file name check doesn't matter if (file.find("library") != -1): print (file) if (not guideline_ok): print("\nGUIDELINE RULES ARE NOT FOLLOWED\n") sys.exit(1) else: sys.exit(0)