vhdl-style-guide/vsg/config.py

384 lines
13 KiB
Python

# -*- coding: utf-8 -*-
import glob
import os
import re
import sys
import yaml
from . import exceptions, junit, severity, utils
def read_predefined_style(sStyleName):
"""
Reads a predefined style file.
Parameters :
sStyleName : (string)
Returns : (dictionary)
"""
dReturn = {}
if sStyleName is not None:
sFileName = os.path.join(os.path.dirname(__file__), "styles", sStyleName + ".yaml")
dReturn = open_configuration_file(sFileName)
return dReturn
def open_configuration_file(sFileName, sJUnitFileName=None):
"""Attempts to open a configuration file and read its contents."""
try:
with open(sFileName) as yaml_file:
dTemp = yaml.full_load(yaml_file)
check_for_deprecated_rule_options(dTemp, sFileName)
return dTemp
except OSError as e:
print(f"ERROR: encountered {e.__class__.__name__}, {e.args[1]} while opening configuration file: " + sFileName)
write_invalid_configuration_junit_file(sFileName, sJUnitFileName)
sys.exit(1)
except (yaml.parser.ParserError, yaml.scanner.ScannerError) as e:
print("ERROR: Invalid configuration file: " + sFileName)
print(e)
write_invalid_configuration_junit_file(sFileName, sJUnitFileName)
sys.exit(1)
except exceptions.ConfigurationError as e:
print(e.message)
sys.exit(1)
def validate_file_exists(sFilename, sConfigName):
"""Validates a file exist while using the glob function to expand filenames."""
if isinstance(sFilename, dict):
sExpandedFilename = list(sFilename.keys())[0]
else:
sExpandedFilename = sFilename
# print(sExpandedFilename)
lFileNames = glob.glob(utils.expand_filename(sExpandedFilename), recursive=True)
# print(lFileNames)
if len(lFileNames) == 0:
print("ERROR: Could not find file " + sFilename + " in configuration file " + sConfigName)
sys.exit(1)
def read_configuration_files(dStyle, commandLineArguments):
if not commandLineArguments.configuration:
return dStyle
dConfiguration = dStyle
lMessages = []
for sConfigFilename in commandLineArguments.configuration:
tempConfiguration = open_configuration_file(sConfigFilename, commandLineArguments.junit)
dConfiguration = process_config_file(dConfiguration, tempConfiguration, sConfigFilename)
return dConfiguration
def process_config_file(dConfiguration, tempConfiguration, sConfigFilename):
dReturn = dConfiguration
for sKey in tempConfiguration.keys():
if sKey == "file_list":
dReturn = process_file_list_key(dReturn, tempConfiguration, sKey, sConfigFilename)
elif sKey == "rule":
for sRule in tempConfiguration[sKey]:
try:
dReturn[sKey][sRule] = tempConfiguration[sKey][sRule]
except KeyError:
dReturn[sKey] = {}
dReturn[sKey][sRule] = tempConfiguration[sKey][sRule]
else:
dReturn[sKey] = tempConfiguration[sKey]
return dReturn
dDeprecatedOption = {}
dDeprecatedOption["indentSize"] = "option indentSize has been deprecated. Change to indent_size."
dDeprecatedOption["indentStyle"] = "option indentStyle has been deprecated. Change to indent_style."
def check_for_deprecated_rule_options(dConfiguration, sConfigFilename):
lMessages = []
lDeprecatedKeys = list(dDeprecatedOption.keys())
search_dictionary(dConfiguration, lDeprecatedKeys, sConfigFilename, lMessages)
if len(lMessages) > 0:
sErrorMessage = ""
for sMessage in lMessages:
sErrorMessage += sMessage + "\n"
raise exceptions.ConfigurationError(sErrorMessage)
def search_dictionary(dDict, lDeprecatedKeys, sConfigFilename, lMessages):
if len(lDeprecatedKeys) == 0:
return None
for sKey in list(dDict.keys()):
if isinstance(dDict[sKey], dict):
search_dictionary(dDict[sKey], lDeprecatedKeys, sConfigFilename, lMessages)
elif isinstance(dDict[sKey], list):
search_list(dDict[sKey], lDeprecatedKeys, sConfigFilename, lMessages)
elif sKey in lDeprecatedKeys:
lMessages.append("ERROR: configuration file " + sConfigFilename + ": " + dDeprecatedOption[sKey])
lDeprecatedKeys.remove(sKey)
def search_list(lDict, lDeprecatedKeys, sConfigFilename, lMessages):
if len(lDeprecatedKeys) == 0:
return None
for sKey in lDict:
if isinstance(sKey, dict):
search_dictionary(sKey, lDeprecatedKeys, sConfigFilename, lMessages)
elif isinstance(sKey, list):
search_list(sKey, lDeprectedKeys, sConfigFilename, lMessages)
elif sKey in lDeprecatedKeys:
lMessages.append("ERROR: configuration file " + sConfigFilename + ": " + dDeprecatedOption[sKey])
lDeprecatedKeys.remove(sKey)
def process_file_list_key(dConfig, tempConfiguration, sKey, sConfigFilename):
dReturn = dConfig
if "file_list" not in dConfig:
dReturn["file_list"] = []
for iIndex, sFilename in enumerate(tempConfiguration["file_list"]):
validate_file_exists(sFilename, sConfigFilename)
try:
for sGlobbedFilename in glob.glob(utils.expand_filename(sFilename), recursive=True):
dReturn["file_list"].append(sGlobbedFilename)
except TypeError:
sKey = list(sFilename.keys())[0]
for sGlobbedFilename in glob.glob(utils.expand_filename(sKey), recursive=True):
dTemp = {}
dTemp[sGlobbedFilename] = {}
dTemp[sGlobbedFilename].update(tempConfiguration["file_list"][iIndex][sKey])
dReturn["file_list"].append(dTemp)
return dReturn
def write_invalid_configuration_junit_file(sFileName, sJUnitFileName):
if sJUnitFileName:
oJunitFile = junit.xmlfile(sJUnitFileName)
oJunitTestsuite = junit.testsuite("vhdl-style-guide", str(0))
oJunitTestcase = junit.testcase(sFileName, str(0))
oFailure = junit.failure("Failure")
oFailure.add_text("Invalid JSON format. Review configuration for errors.")
oJunitTestcase.add_failure(oFailure)
oJunitTestsuite.add_testcase(oJunitTestcase)
oJunitFile.add_testsuite(oJunitTestsuite)
utils.write_junit_xml_file(oJunitFile)
def add_debug_to_configuration(oCLA, dConfiguration):
"""
Adds debug values to the configuration dictionary for later use.
Parameters:
oCLA: (command line argument object)
dConfiguration: (dictionary)
Returns: Nothing
"""
try:
dConfiguration["debug"] = oCLA.debug
except TypeError:
dConfiguration = {}
dConfiguration["debug"] = oCLA.debug
return dConfiguration
def read_indent_configuration(dConfiguration):
"""
Reads the default indent dictionary and merges any changes from a user configuration.
Parameters:
dConfiguration: (dictionary)
Returns: (dictionary)
"""
sFileName = os.path.join(os.path.dirname(__file__), "vhdlFile", "indent", "indent_config.yaml")
dReturn = open_configuration_file(sFileName)
if "indent" not in list(dConfiguration.keys()):
dConfiguration["indent"] = dReturn["indent"]
return dReturn
### This merges an indent configuration into the base indent dictionary
try:
dGroups = dConfiguration["indent"]["tokens"]
for sGroup in list(dGroups.keys()):
for sToken in list(dGroups[sGroup].keys()):
for sParameter in list(dGroups[sGroup][sToken].keys()):
dReturn["indent"]["tokens"][sGroup][sToken][sParameter] = dGroups[sGroup][sToken][sParameter]
except KeyError:
report_indent_configuration_error(dReturn, sGroup, sToken)
dConfiguration["indent"] = dReturn["indent"]
return dReturn
def report_indent_configuration_error(dReturn, sGroup, sToken):
print("ERROR: Invalid indent configuration detected")
report_invalid_indent_group(dReturn, sGroup)
report_invalid_indent_token(dReturn, sGroup, sToken)
def report_invalid_indent_group(dReturn, sGroup):
try:
lTemp = list(dReturn["indent"]["tokens"][sGroup].keys())
except KeyError:
print("The following group does not exist")
print("")
print("indent:")
print(" tokens:")
print(f" {sGroup}:")
print("")
print("The following groups are available:")
print("")
print("indent:")
print(" tokens:")
for sMyGroup in list(dReturn["indent"]["tokens"].keys()):
print(f" {sMyGroup}:")
sys.exit(1)
def report_invalid_indent_token(dReturn, sGroup, sToken):
try:
lTemp = list(dReturn["indent"]["tokens"][sGroup][sToken].keys())
except KeyError:
print("The following token does not exist")
print("")
print("indent:")
print(" tokens:")
print(f" {sGroup}:")
print(f" {sToken}:")
print("")
print("The following tokens are available:")
print("")
print("indent:")
print(" tokens:")
print(f" {sGroup}:")
for sMyToken in list(dReturn["indent"]["tokens"][sGroup].keys()):
print(f" {sMyToken}:")
sys.exit(1)
def update_command_line_arguments(commandLineArguments, configuration):
if "skip_phase" in configuration:
commandLineArguments.skip_phase = configuration["skip_phase"]
else:
commandLineArguments.skip_phase = []
if not configuration:
return
if "file_list" in configuration:
for sFilename in configuration["file_list"]:
if isinstance(sFilename, dict):
sFilename = list(sFilename.keys())[0]
try:
lFileNames = glob.glob(utils.expand_filename(sFilename), recursive=True)
for sFileName in lFileNames:
if sFileName not in commandLineArguments.filename:
commandLineArguments.filename.append(sFileName)
except:
commandLineArguments.filename = glob.glob(utils.expand_filename(sFilename), recursive=True)
if "local_rules" in configuration:
commandLineArguments.local_rules = utils.expand_filename(configuration["local_rules"])
dPragmas = {}
dPragmas["open"] = []
dPragmas["close"] = []
dPragmas["single"] = []
dPragmas["open"].append("^\\s*--\\s+synthesis\\s+translate_off\\s*$")
dPragmas["close"].append("^\\s*--\\s+synthesis\\s+translate_on\\s*$")
dPragmas["single"].append("^\\s*--\\s+synthesis\\s+\\w+\\s*$")
dPragmas["single"].append("^\\s*--\\s+synthesis\\s+\\w+\\s+\\w+\\s*$")
dPragmas["single"].append("^\\s*--\\s+pragma\\s+\\w+\\s*$")
dPragmas["single"].append("^\\s*--\\s+pragma\\s+\\w+\\s+\\w+\\s*$")
dPragmas["open"].append("^\\s*--vhdl_comp_off\\s*$")
dPragmas["close"].append("^\\s*--vhdl_comp_on\\s*$")
dPragmas["single"].append("^\\s*--\\s+altera\\s+\\w+\\s*$")
dPragmas["open"].append("^\\s*--\\s+RTL_SYNTHESIS\\s+OFF\\s*$")
dPragmas["close"].append("^\\s*--\\s+RTL_SYNTHESIS\\s+ON\\s*$")
dPragmas["single"].append("^\\s*--\\s+synopsys\\s+\\w+\\s*$")
dPragmas["single"].append("^\\s*--\\s+synopsys\\s+\\w+\\s+\\w+\\s*$")
dPragmas["single"].append("^\\s*--\\s+xilinx\\s+\\w+\\s*$")
dPragmas["single"].append("^\\s*--\\s+xilinx\\s+\\w+\\s+\\w+\\s*$")
def add_pragma_regular_expressions(dStyle):
if not "pragma" in dStyle.keys():
dStyle["pragma"] = {}
dStyle["pragma"]["patterns"] = dPragmas
dStyle["pragma"]["regexp"] = {}
try:
types = list(dStyle["pragma"]["patterns"].keys())
if "close" not in types:
dStyle["pragma"]["patterns"]["close"] = []
if "open" not in types:
dStyle["pragma"]["patterns"]["open"] = []
if "single" not in types:
dStyle["pragma"]["patterns"]["single"] = []
for types in list(dStyle["pragma"]["patterns"].keys()):
for pragma in dStyle["pragma"]["patterns"][types]:
try:
dStyle["pragma"]["regexp"][types].append(re.compile(pragma))
except KeyError:
dStyle["pragma"]["regexp"][types] = []
dStyle["pragma"]["regexp"][types].append(re.compile(pragma))
except AttributeError as e:
print("Error in pragma definition:")
print(' Refer to "configuring pragmas" section in documentation for details on how to configure pragmas.')
sys.exit(1)
def New(commandLineArguments):
oReturn = config()
dStyle = read_predefined_style(commandLineArguments.style)
dConfig = read_configuration_files(dStyle, commandLineArguments)
add_pragma_regular_expressions(dConfig)
oReturn.severity_list = severity.create_list(dConfig)
update_command_line_arguments(commandLineArguments, dConfig)
dConfig = add_debug_to_configuration(commandLineArguments, dConfig)
oReturn.dConfig = dConfig
dIndent = read_indent_configuration(dConfig)
oReturn.dIndent = dIndent
if commandLineArguments.fix_only:
oReturn.dFixOnly = open_configuration_file(commandLineArguments.fix_only)
else:
oReturn.dFixOnly = None
return oReturn
class config:
def __init__(self):
dIndent = None
dConfig = None
dFixOnly = None
severity_list = None