286 lines
8.5 KiB
Python
286 lines
8.5 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
from vsg import parser, token, violation
|
|
from vsg.rules import utils as rules_utils
|
|
from vsg.vhdlFile import utils
|
|
|
|
|
|
def build_solution(sIndent):
|
|
sSolution = "Indent with "
|
|
if "\t" in sIndent and " " in sIndent:
|
|
sSolution += str(sIndent.count("\t")) + " tab(s) followed by " + str(sIndent.count(" ")) + " space(s)"
|
|
elif "\t" in sIndent:
|
|
sSolution += str(sIndent.count("\t")) + " tab(s)"
|
|
elif " " in sIndent:
|
|
sSolution += str(sIndent.count(" ")) + " space(s)"
|
|
return sSolution
|
|
|
|
|
|
def convert_expected_indent_to_smart_tab(dExpectedIndent, indent_size, iFirstLineIndent):
|
|
iFirstLine = get_first_line(dExpectedIndent)
|
|
iLastLine = get_last_line(dExpectedIndent)
|
|
for iLine in range(iFirstLine + 1, iLastLine + 1):
|
|
dExpectedIndent[iLine] = "\t" + dExpectedIndent[iLine][iFirstLineIndent:]
|
|
|
|
|
|
def get_first_line(dActualIndent):
|
|
lLines = list(dActualIndent.keys())
|
|
lLines.sort()
|
|
iLine = lLines[0]
|
|
return iLine
|
|
|
|
|
|
def get_first_line_info(iLine, oFile):
|
|
lTemp = oFile.get_tokens_from_line(iLine)
|
|
iIndent = len(lTemp.get_tokens()[0].get_value())
|
|
return iLine, iIndent
|
|
|
|
|
|
def get_last_line(dActualIndent):
|
|
lLines = list(dActualIndent.keys())
|
|
lLines.sort()
|
|
iLine = lLines[-1]
|
|
return iLine
|
|
|
|
|
|
def set_indent(iToken, lTokens):
|
|
iReturn = 0
|
|
if isinstance(lTokens[iToken + 1], parser.whitespace):
|
|
iReturn = lTokens[iToken + 1].get_value()
|
|
else:
|
|
iReturn = ""
|
|
return iReturn
|
|
|
|
|
|
def starts_with_paren(lTokens):
|
|
iToken = utils.find_next_non_whitespace_token(1, lTokens)
|
|
try:
|
|
if isinstance(lTokens[iToken], parser.open_parenthesis):
|
|
return True
|
|
except IndexError:
|
|
if isinstance(lTokens[0], parser.open_parenthesis):
|
|
return True
|
|
return False
|
|
|
|
|
|
def update_column_width(self, oToken):
|
|
sToken = oToken.get_value()
|
|
if isinstance(oToken, parser.whitespace):
|
|
iTabs = sToken.count("\t")
|
|
iLength = len(sToken) + (iTabs * self.indent_size) - iTabs
|
|
return iLength
|
|
|
|
return len(oToken.get_value())
|
|
|
|
|
|
def add_adjustments_to_dAnalysis(dAnalysis, compact_alignment, include_lines_without_comments=False, iMaxColumn=0):
|
|
iMaxLeftColumn = 0
|
|
iMinLeftColumn = 9999999999999999
|
|
iMaxTokenColumn = 0
|
|
iMinTokenColumn = 9999999999999999
|
|
|
|
for iKey in list(dAnalysis.keys()):
|
|
iMaxLeftColumn = max(iMaxLeftColumn, dAnalysis[iKey]["left_column"])
|
|
iMinLeftColumn = min(iMinLeftColumn, dAnalysis[iKey]["left_column"])
|
|
iMaxTokenColumn = max(iMaxTokenColumn, dAnalysis[iKey]["token_column"])
|
|
iMinTokenColumn = min(iMinTokenColumn, dAnalysis[iKey]["token_column"])
|
|
|
|
if include_lines_without_comments:
|
|
iMaxTokenColumn = max(iMaxTokenColumn, iMaxColumn)
|
|
|
|
if compact_alignment:
|
|
for iKey in list(dAnalysis.keys()):
|
|
dAnalysis[iKey]["adjust"] = iMaxLeftColumn - dAnalysis[iKey]["token_column"] + 1
|
|
else:
|
|
for iKey in list(dAnalysis.keys()):
|
|
dAnalysis[iKey]["adjust"] = iMaxTokenColumn - dAnalysis[iKey]["token_column"]
|
|
|
|
|
|
def check_for_exclusions(oToken, bSkip, oEndSkipToken, lUnless):
|
|
if bSkip:
|
|
if isinstance(oToken, oEndSkipToken):
|
|
return False, None
|
|
else:
|
|
for lTokenPairs in lUnless:
|
|
if isinstance(oToken, lTokenPairs[0]):
|
|
return True, lTokenPairs[1]
|
|
|
|
return bSkip, oEndSkipToken
|
|
|
|
|
|
def check_for_if_keywords(iToken, lTokens):
|
|
iMyToken = iToken
|
|
if isinstance(lTokens[iToken], parser.whitespace):
|
|
iMyToken += 1
|
|
|
|
if isinstance(lTokens[iMyToken], token.if_statement.if_label):
|
|
return True
|
|
|
|
if isinstance(lTokens[iMyToken], token.if_statement.if_keyword):
|
|
return True
|
|
|
|
if isinstance(lTokens[iMyToken], token.if_statement.elsif_keyword):
|
|
return True
|
|
|
|
if isinstance(lTokens[iMyToken], token.if_statement.else_keyword):
|
|
return True
|
|
|
|
if isinstance(lTokens[iMyToken], token.if_statement.end_keyword):
|
|
return True
|
|
|
|
return False
|
|
|
|
|
|
def check_for_case_keywords(iToken, lTokens):
|
|
iMyToken = iToken
|
|
if isinstance(lTokens[iToken], parser.whitespace):
|
|
iMyToken += 1
|
|
|
|
if isinstance(lTokens[iMyToken], token.case_statement.case_label):
|
|
return True
|
|
|
|
if isinstance(lTokens[iMyToken], token.case_statement.case_keyword):
|
|
return True
|
|
|
|
if isinstance(lTokens[iMyToken], token.case_statement.end_keyword):
|
|
return True
|
|
|
|
return False
|
|
|
|
|
|
def check_for_when_keywords(iToken, lTokens):
|
|
iMyToken = iToken
|
|
if isinstance(lTokens[iToken], parser.whitespace):
|
|
iMyToken += 1
|
|
|
|
if isinstance(lTokens[iMyToken], token.case_statement_alternative.when_keyword):
|
|
return True
|
|
|
|
return False
|
|
|
|
|
|
def check_for_loop_keywords(iToken, lTokens):
|
|
iMyToken = iToken
|
|
if isinstance(lTokens[iToken], parser.whitespace):
|
|
iMyToken += 1
|
|
|
|
if isinstance(lTokens[iMyToken], token.loop_statement.loop_label):
|
|
return True
|
|
|
|
if isinstance(lTokens[iMyToken], token.iteration_scheme.while_keyword):
|
|
return True
|
|
|
|
if isinstance(lTokens[iMyToken], token.iteration_scheme.for_keyword):
|
|
return True
|
|
|
|
if isinstance(lTokens[iMyToken], token.loop_statement.loop_keyword):
|
|
return True
|
|
|
|
if isinstance(lTokens[iMyToken], token.loop_statement.end_keyword):
|
|
return True
|
|
|
|
if isinstance(lTokens[iMyToken], token.loop_statement.end_loop_keyword):
|
|
return True
|
|
|
|
return False
|
|
|
|
|
|
def check_for_aggregate_parens(iToken, lTokens):
|
|
iMyToken = iToken
|
|
|
|
if isinstance(lTokens[iMyToken], token.aggregate.open_parenthesis):
|
|
return True
|
|
|
|
if isinstance(lTokens[iMyToken], token.aggregate.close_parenthesis):
|
|
return True
|
|
|
|
return False
|
|
|
|
|
|
def is_single_line_aggregate(iToken, lTokens):
|
|
if not isinstance(lTokens[iToken], token.aggregate.open_parenthesis):
|
|
return False
|
|
|
|
for iIndex in range(iToken, len(lTokens)):
|
|
if isinstance(lTokens[iIndex], parser.carriage_return):
|
|
return False
|
|
if isinstance(lTokens[iIndex], token.aggregate.close_parenthesis):
|
|
if lTokens[iIndex].iId == lTokens[iToken].iId:
|
|
return True
|
|
return False
|
|
|
|
|
|
def check_for_violations(self, dAnalysis, oFile):
|
|
add_adjustments_to_dAnalysis(dAnalysis, self.compact_alignment)
|
|
for iKey in list(dAnalysis.keys()):
|
|
if dAnalysis[iKey]["adjust"] != 0:
|
|
oLineTokens = oFile.get_tokens_from_line(iKey)
|
|
sSolution = "Move " + dAnalysis[iKey]["token_value"] + " " + str(dAnalysis[iKey]["adjust"]) + " columns"
|
|
oViolation = violation.New(oLineTokens.get_line_number(), oLineTokens, sSolution)
|
|
oViolation.set_action(dAnalysis[iKey])
|
|
self.add_violation(oViolation)
|
|
|
|
|
|
def generate_statement_detected(self, oToken):
|
|
if not self.generate_statement_ends_group:
|
|
return False
|
|
if generate_label_detected(oToken):
|
|
return True
|
|
if generate_semicolon_detected(oToken):
|
|
return True
|
|
if case_generate_alternative_detected(oToken):
|
|
return True
|
|
return False
|
|
|
|
|
|
def generate_label_detected(oToken):
|
|
if isinstance(oToken, token.if_generate_statement.generate_label):
|
|
return True
|
|
if isinstance(oToken, token.for_generate_statement.generate_label):
|
|
return True
|
|
return False
|
|
|
|
|
|
def generate_semicolon_detected(oToken):
|
|
if isinstance(oToken, token.if_generate_statement.semicolon):
|
|
return True
|
|
if isinstance(oToken, token.for_generate_statement.semicolon):
|
|
return True
|
|
if isinstance(oToken, token.case_generate_statement.semicolon):
|
|
return True
|
|
return False
|
|
|
|
|
|
def case_generate_alternative_detected(oToken):
|
|
if isinstance(oToken, token.case_generate_alternative.when_keyword):
|
|
return True
|
|
return False
|
|
|
|
|
|
def is_case_control_enabled(config):
|
|
if config == "break_on_case_or_end_case":
|
|
return True
|
|
return config
|
|
|
|
|
|
def is_case_keyword(config, iIndex, lTokens):
|
|
if check_for_case_keywords(iIndex + 1, lTokens):
|
|
return True
|
|
if check_for_when_keywords(iIndex + 1, lTokens):
|
|
if config != "break_on_case_or_end_case":
|
|
return True
|
|
return False
|
|
|
|
|
|
def unless_region_detected(oToken, lUnless):
|
|
for lTokenPairs in lUnless:
|
|
if isinstance(oToken, lTokenPairs[0]):
|
|
return True
|
|
return False
|
|
|
|
|
|
def get_index_of_end_unless_region(oToken, lTokens, lUnless, iIndex):
|
|
for lTokenPairs in lUnless:
|
|
if isinstance(oToken, lTokenPairs[0]):
|
|
return rules_utils.get_index_of_token_in_list_after_index(lTokenPairs[1], lTokens, iIndex)
|