vhdl-style-guide/vsg/rules/consistent_interface_token_...

287 lines
9.6 KiB
Python

# -*- coding: utf-8 -*-
from vsg import token, violation
from vsg.rule_group import case
lInterfaceTokens = []
lInterfaceTokens.append(token.interface_unknown_declaration.identifier)
lInterfaceTokens.append(token.interface_constant_declaration.identifier)
lInterfaceTokens.append(token.interface_variable_declaration.identifier)
lInterfaceTokens.append(token.interface_signal_declaration.identifier)
lPairs = []
lPairs.append([token.concurrent_simple_signal_assignment.target, token.concurrent_simple_signal_assignment.semicolon])
lPairs.append([token.concurrent_conditional_signal_assignment.target, token.concurrent_conditional_signal_assignment.semicolon])
lPairs.append([token.constant_declaration.colon, token.constant_declaration.semicolon])
lPairs.append([token.signal_declaration.colon, token.signal_declaration.semicolon])
lPairs.append([token.variable_declaration.colon, token.variable_declaration.semicolon])
lPairs.append([token.process_statement.open_parenthesis, token.process_statement.close_parenthesis])
lPairs.append([token.process_statement.begin_keyword, token.process_statement.end_keyword])
oStartToken = token.architecture_body.entity_name
oEndToken = token.architecture_body.end_keyword
class consistent_interface_token_case(case.Rule):
"""
Checks the case for generic and port identifiers.
Parameters
----------
name : string
The group the rule belongs to.
identifier : string
unique identifier. Usually in the form of 00N.
lTokens: list of token type objects
token type to apply the case check against
"""
def __init__(self):
super().__init__()
self.subphase = 2
self.configuration_documentation_link = None
self.map_aspect_token = None
self.clause_token = None
self.interface_string = None
def analyze(self, oFile):
lInterfaces = extract_interface_names_from_entities(oFile, self.clause_token)
if no_interfaces_detected(lInterfaces):
return None
lArchitectures = oFile.get_tokens_bounded_by(oStartToken, oEndToken)
for oArchitecture in lArchitectures:
oArchitecture.name = extract_entity_name(oArchitecture)
try:
lArchitectureInterfaces = lInterfaces[oArchitecture.name]
except KeyError:
continue
lToi = extract_token_pairs(oArchitecture, lPairs)
lToi.extend(extract_component_instantiation_actual_parts(oArchitecture, self.map_aspect_token))
for oToi in lToi:
validate_interface_name_in_token_list(self, lArchitectureInterfaces, oToi, self.interface_string)
def _fix_violation(self, oViolation):
lTokens = oViolation.get_tokens()
dActions = oViolation.get_action()
lTokens[0].set_value(dActions["value"])
oViolation.set_tokens(lTokens)
def extract_component_instantiation_actual_parts(oArchitecture, oMapAspectToken):
lReturn = []
lInstantiations = extract_component_instantiations(oArchitecture)
for oInstantiation in lInstantiations:
lGenericMapAspects = extract_generic_map_aspect(oInstantiation)
lReturn.extend(extract_actual_part_tokens_from_aspects(lGenericMapAspects))
lInterfaceMapAspects = extract_interface_map_aspect(oInstantiation, oMapAspectToken)
lReturn.extend(extract_actual_part_tokens_from_aspects(lInterfaceMapAspects))
return lReturn
def extract_component_instantiations(oArchitecture):
return extract_token_pairs(oArchitecture, [[token.component_instantiation_statement.label_colon, token.component_instantiation_statement.semicolon]])
def extract_generic_map_aspect(oInstantiation):
return extract_token_pairs(oInstantiation, [[token.generic_map_aspect.open_parenthesis, token.generic_map_aspect.close_parenthesis]])
def extract_interface_map_aspect(oInstantiation, oMapAspectToken):
return extract_token_pairs(oInstantiation, [[oMapAspectToken.open_parenthesis, oMapAspectToken.close_parenthesis]])
def extract_actual_part_tokens_from_aspects(lMapAspect):
lReturn = []
for oMapAspect in lMapAspect:
lReturn.extend(extract_actual_part_tokens_from_aspect(oMapAspect))
return lReturn
def extract_actual_part_tokens_from_aspect(oMapAspect):
lReturn = []
for iToken, oToken in enumerate(oMapAspect.get_tokens()):
lReturn.extend(extract_actual_part_token(oMapAspect, iToken, oToken))
return lReturn
def extract_actual_part_token(oMapAspect, iToken, oToken):
lReturn = []
if is_actual_part_token(oToken):
lReturn.append(oMapAspect.extract_tokens(iToken, iToken))
return lReturn
def is_actual_part_token(oToken):
if isinstance(oToken, token.association_element.actual_part):
return True
return False
def no_interfaces_detected(lInterfaces):
if len(lInterfaces) == 0:
return True
return False
def validate_interface_name_in_token_list(self, lMyInterfaces, oToi, sInterface):
lMyInterfacesLower = []
dInterfaceMap = {}
for sInterfaceName in lMyInterfaces:
lMyInterfacesLower.append(sInterfaceName.lower())
dInterfaceMap[sInterfaceName.lower()] = sInterfaceName
lTokens = oToi.get_tokens()
for iToken, oToken in enumerate(lTokens):
sToken = oToken.get_value()
if interface_case_mismatch(sToken, lMyInterfaces, lMyInterfacesLower):
oViolation = create_violation(sInterface, sToken, iToken, dInterfaceMap, oToi)
self.add_violation(oViolation)
def create_violation(sInterface, sToken, iToken, dInterfaceMap, oToi):
sSolution = sInterface + " case mismatch: Change " + sToken + " to " + dInterfaceMap[sToken.lower()]
oNewToi = oToi.extract_tokens(iToken, iToken)
oViolation = violation.New(oNewToi.get_line_number(), oNewToi, sSolution)
dAction = {}
dAction["value"] = dInterfaceMap[sToken.lower()]
oViolation.set_action(dAction)
return oViolation
def skip_code(oToken, bSkip):
bReturn = bSkip
if not bSkip:
return start_of_skip_region_found(oToken, bReturn)
return end_of_skip_region_found(oToken, bReturn)
def end_of_skip_region_found(oToken, bReturn):
if isinstance(oToken, token.subprogram_body.semicolon):
return False
return True
def start_of_skip_region_found(oToken, bReturn):
bReturn = function_keyword_found(oToken, bReturn)
bReturn = procedure_keyword_found(oToken, bReturn)
return bReturn
def function_keyword_found(oToken, bReturn):
if isinstance(oToken, token.function_specification.function_keyword):
return True
return bReturn
def procedure_keyword_found(oToken, bReturn):
if isinstance(oToken, token.procedure_specification.procedure_keyword):
return True
return bReturn
def interface_case_mismatch(sToken, lInterfaces, lInterfacesLower):
if sToken.lower() in lInterfacesLower and sToken not in lInterfaces:
return True
return False
def extract_token_pairs(oArchitecture, lPairs):
lReturn = []
for lPair in lPairs:
lReturn.extend(extract_token_pair(oArchitecture, lPair))
return lReturn
def extract_token_pair(oArchitecture, lPair):
lReturn = []
bSkip = False
iStart = None
for iToken, oToken in enumerate(oArchitecture.get_tokens()):
bSkip = skip_code(oToken, bSkip)
if bSkip:
continue
iStart = set_start_index(iToken, oToken, lPair, iStart)
lReturn.extend(extract_tokens_if_end_is_found(oArchitecture, iToken, oToken, lPair, iStart))
return lReturn
def extract_tokens_if_end_is_found(oArchitecture, iToken, oToken, lPair, iStart):
lReturn = []
if isinstance(oToken, lPair[1]):
lReturn.append(oArchitecture.extract_tokens(iStart, iToken))
return lReturn
def set_start_index(iToken, oToken, lPair, iStart):
if isinstance(oToken, lPair[0]):
return iToken
return iStart
def extract_interface_names_from_entities(oFile, oClauseToken):
lEntities = oFile.get_tokens_bounded_by(token.entity_declaration.identifier, token.entity_declaration.end_keyword)
lInterfaces = {}
for oEntity in lEntities:
oEntity.name = extract_entity_name(oEntity)
lInterfaceNames = extract_interface_names(oEntity, oClauseToken)
if lInterfaceNames != []:
lInterfaces[oEntity.name] = lInterfaceNames
return lInterfaces
def extract_entity_name(oToi):
lTokens = oToi.get_tokens()
for oToken in lTokens:
if isinstance(oToken, token.entity_declaration.identifier):
return oToken.get_lower_value()
if isinstance(oToken, token.architecture_body.entity_name):
return oToken.get_lower_value()
def extract_interface_names(oToi, oClauseToken):
lReturn = []
bSearch = False
for oToken in oToi.get_tokens():
bSearch = end_search(oToken, bSearch, oClauseToken)
lReturn.extend(extract_interface_token(bSearch, oToken, lInterfaceTokens))
bSearch = start_search(oToken, bSearch, oClauseToken)
return lReturn
def end_search(oToken, bSearch, oClauseToken):
if isinstance(oToken, oClauseToken.close_parenthesis):
return False
return bSearch
def extract_interface_token(bSearch, oToken, lInterfaceTokens):
lReturn = []
if bSearch:
if is_token_in_token_type_list(oToken, lInterfaceTokens):
lReturn.append(oToken.get_value())
return lReturn
def start_search(oToken, bSearch, oClauseToken):
if isinstance(oToken, oClauseToken.open_parenthesis):
return True
return bSearch
def is_token_in_token_type_list(oToken, lTokenTypes):
for oTokenType in lTokenTypes:
if isinstance(oToken, oTokenType):
return True
return False