282 lines
9.5 KiB
Python
282 lines
9.5 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)
|
|
lArchitectureInterfaces = lInterfaces[oArchitecture.name]
|
|
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
|