vhdl-style-guide/vsg/rules/alignment_utils.py

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)