From aae2fc9a4e3d1b4146fd42d64b06b06cbb5f8f08 Mon Sep 17 00:00:00 2001 From: Jeremiah C Leary Date: Sun, 31 Mar 2019 09:54:08 -0500 Subject: [PATCH] Updates for issue #224 Adding case consistency checks for variable names: 1) Added documentation 2) Added tests 3) Added rule variable_011 --- docs/variable_rules.rst | 58 ++++++++++++++++ vsg/rules/variable/__init__.py | 1 + vsg/rules/variable/rule_011.py | 68 +++++++++++++++++++ .../code_examples/c16/data_core.fixed.vhd | 8 +-- .../variable/consistent_case_test_input.vhd | 27 ++++++++ vsg/tests/variable/test_consistent_case.py | 38 +++++++++++ vsg/utils.py | 14 ++++ 7 files changed, 210 insertions(+), 4 deletions(-) create mode 100644 vsg/rules/variable/rule_011.py create mode 100644 vsg/tests/variable/consistent_case_test_input.vhd create mode 100644 vsg/tests/variable/test_consistent_case.py diff --git a/docs/variable_rules.rst b/docs/variable_rules.rst index 40df678b..2a3dfaa1 100644 --- a/docs/variable_rules.rst +++ b/docs/variable_rules.rst @@ -178,3 +178,61 @@ This rule checks the variable type is lowercase. variable count : integer; +variable_011 +############ + +This rule checks for consistent capitalization of variable names. + +**Violation** + +.. code-block:: vhdl + + architecture RTL of ENTITY1 is + + shared variable var1 : std_logic; + shared variable var2 : std_logic; + + begin + + PROC_NAME : process () is + + variable var3 : std_logic; + variable var4 : std_logic; + + begin + + Var1 <= '0'; + + if (VAR2 = '0') then + vaR3 <= '1'; + elisif (var2 = '1') then + VAR4 <= '0'; + end if; + + end process PROC_NAME; + + end architecture RTL; + +**Fix** + +.. code-block:: vhdl + + PROC_NAME : process () is + + variable var1 : std_logic; + variable var2 : std_logic; + variable var3 : std_logic; + variable var4 : std_logic; + + begin + + var1 <= '0'; + + if (var2 = '0') then + var3 <= '1'; + elisif (var2 = '1') then + var4 <= '0'; + end if; + + end process PROC_NAME; + diff --git a/vsg/rules/variable/__init__.py b/vsg/rules/variable/__init__.py index 846cc02f..a97fcd8e 100644 --- a/vsg/rules/variable/__init__.py +++ b/vsg/rules/variable/__init__.py @@ -9,3 +9,4 @@ from .rule_007 import rule_007 from .rule_009 import rule_009 from .rule_010 import rule_010 +from .rule_011 import rule_011 diff --git a/vsg/rules/variable/rule_011.py b/vsg/rules/variable/rule_011.py new file mode 100644 index 00000000..6a9b43d5 --- /dev/null +++ b/vsg/rules/variable/rule_011.py @@ -0,0 +1,68 @@ + +from vsg import rule +from vsg import utils + + +class rule_011(rule.rule): + ''' + General rule 011 checks capitalization consistency of variable names. + ''' + + def __init__(self): + rule.rule.__init__(self, 'variable', '011') + self.fixable = True + self.solution = 'Inconsistent capitalization of word' + self.phase = 6 + self.lLowerCaseWords = [] + self.lCaseWords = [] + self.dDatabase = create_database() + + def _analyze(self, oFile, oLine, iLineNumber): + if oLine.isVariable: + self.dDatabase['variable'].append(utils.extract_variable_name(oLine)) + if oLine.insideProcess: + lWords = extract_word_list(oLine) + check_violations(self, lWords, iLineNumber) + + def _fix_violations(self, oFile): + for iLineNumber in self.violations: + for sWord in self.dFix['violations'][iLineNumber]: + sReplacementWord = get_replacement_word(self, sWord) + utils.change_word(oFile.lines[iLineNumber], sWord, sReplacementWord, 20) + + def _get_solution(self, iLineNumber): + if len(self.dFix['violations'][iLineNumber]) > 1: + sSolution = self.solution + 's: ' + ', '.join(self.dFix['violations'][iLineNumber]) + else: + sSolution = self.solution + ': ' + ', '.join(self.dFix['violations'][iLineNumber]) + return sSolution + +def create_database(): + + dDatabase = {} + dDatabase['variable'] = [] + + return dDatabase + +def extract_word_list(oLine): + + sLine = oLine.line + + return utils.extract_non_keywords(sLine) + +def check_violations(self, lWords, iLineNumber): + + for sWord in lWords: + if sWord.lower() in map(str.lower, self.dDatabase['variable']): + if not sWord in self.dDatabase['variable']: + self.add_violation(iLineNumber) + try: + self.dFix['violations'][iLineNumber].append(sWord) + except KeyError: + self.dFix['violations'][iLineNumber] = [] + self.dFix['violations'][iLineNumber].append(sWord) + +def get_replacement_word(self, sWord): + for sNewWord in self.dDatabase['variable']: + if sNewWord.lower() == sWord.lower(): + return sNewWord diff --git a/vsg/tests/code_examples/c16/data_core.fixed.vhd b/vsg/tests/code_examples/c16/data_core.fixed.vhd index c011a36b..072e823f 100644 --- a/vsg/tests/code_examples/c16/data_core.fixed.vhd +++ b/vsg/tests/code_examples/c16/data_core.fixed.vhd @@ -133,9 +133,9 @@ begin begin - SAX := SA(4 downto 3); + sax := SA(4 downto 3); - case SAX is + case sax is when SA_43_I16 => adr_x <= IMM; @@ -154,9 +154,9 @@ begin begin - SAZ := SA(2 downto 1); + saz := SA(2 downto 1); - case SAZ is + case saz is when SA_21_0 => adr_z <= X"0000"; diff --git a/vsg/tests/variable/consistent_case_test_input.vhd b/vsg/tests/variable/consistent_case_test_input.vhd new file mode 100644 index 00000000..1f6a231e --- /dev/null +++ b/vsg/tests/variable/consistent_case_test_input.vhd @@ -0,0 +1,27 @@ + +architecture RTL of ENTITY1 is + + +begin + + PROC_NAME : process () is + + variable var1 : std_logic; + variable var2 : std_logic; + variable var3 : std_logic; + variable var4 : std_logic; + + begin + + Var1 <= '0'; + + if (VAR2 = '0') then + vaR3 <= '1'; + elsif (var2 = '1') then + VAR4 <= '0'; + end if; + + end process PROC_NAME; + +end architecture RTL; + diff --git a/vsg/tests/variable/test_consistent_case.py b/vsg/tests/variable/test_consistent_case.py new file mode 100644 index 00000000..d6fb5d82 --- /dev/null +++ b/vsg/tests/variable/test_consistent_case.py @@ -0,0 +1,38 @@ +import os + +import unittest +import sys +sys.path.append('vsg') + +from vsg.rules import variable +from vsg import vhdlFile +from vsg.tests import utils + + +class testConsistentCase(unittest.TestCase): + + def setUp(self): + # Read in test file used for all tests + lFile = utils.read_vhdlfile(os.path.join(os.path.dirname(__file__),'consistent_case_test_input.vhd')) + self.oFile = vhdlFile.vhdlFile(lFile) + + def test_rule_011(self): + oRule = variable.rule_011() + self.assertTrue(oRule) + self.assertEqual(oRule.name, 'variable') + self.assertEqual(oRule.identifier, '011') + dExpected = [16, 18, 19, 21] + oRule.analyze(self.oFile) + self.assertEqual(oRule.violations, dExpected) + + def test_fix_rule_011(self): + oRule = variable.rule_011() + oRule.fix(self.oFile) + oRule.analyze(self.oFile) + + self.assertEqual(self.oFile.lines[16].line, ' var1 <= \'0\';') + self.assertEqual(self.oFile.lines[18].line, ' if (var2 = \'0\') then') + self.assertEqual(self.oFile.lines[19].line, ' var3 <= \'1\';') + self.assertEqual(self.oFile.lines[21].line, ' var4 <= \'0\';') + + self.assertEqual(oRule.violations, []) diff --git a/vsg/utils.py b/vsg/utils.py index 7f4b9aa0..d0155d5c 100644 --- a/vsg/utils.py +++ b/vsg/utils.py @@ -569,3 +569,17 @@ def extract_type_name(oLine): ''' sLine = oLine.line.split(':')[0] return sLine.split()[1] + + +def extract_variable_name(oLine): + ''' + Returns the name of a variable in a variable declaration. + + Parameters: + + oLine: (line object) + + Returns: (string) + ''' + sLine = oLine.line.split(':')[0] + return sLine.split()[1]