|
|
#!/usr/bin/tclsh
|
|
|
# Naming conventions for variables
|
|
|
|
|
|
set localVariableRegex [getParameter "local-var-regex" {^[a-z][A-Za-z1-9]*$}]
|
|
|
set classMemberVariableRegex [getParameter "class-member-var-regex" {^m_[A-Z][A-Za-z1-9]*$}]
|
|
|
set structMemberVariableRegex [getParameter "struct-member-var-regex" {^[a-z][A-Za-z1-9]*$}]
|
|
|
set staticMemberVariableRegex [getParameter "static-member-var-regex" {^s_[A-Z][A-Za-z1-9]*$}]
|
|
|
set constVarRegex [getParameter "const-var-regex" {^[A-Z][A-Z1-9_]*$}]
|
|
|
|
|
|
proc createMachine {machineName initState} {
|
|
|
set machine [dict create name $machineName state $initState previousState "" identifier "" bracesCounter 0 bracketCounter 0 angleBracketCounter 0]
|
|
|
|
|
|
# Specific keys for the "memberVariable" type
|
|
|
if {$machineName == "memberVariable"} {
|
|
|
dict set machine parenCounter 0
|
|
|
dict set machine isStatic 0
|
|
|
dict set machine isConst 0
|
|
|
dict set machine isVar 1
|
|
|
dict set machine isTypedef 0
|
|
|
dict set machine isInClass 0
|
|
|
dict set machine classOrStruct ""
|
|
|
}
|
|
|
|
|
|
return $machine
|
|
|
}
|
|
|
|
|
|
proc isClassMacro {value} {
|
|
|
set classMacroRegexp [getParameter "classmacro-regex" {}]
|
|
|
set classMacros {
|
|
|
"Q_OBJECT"
|
|
|
}
|
|
|
set isClassMacroByRegexp 0
|
|
|
if {[string length $classMacroRegexp] != 0} {
|
|
|
set isClassMacroByRegexp [regexp $classMacroRegexp $value]
|
|
|
}
|
|
|
return [expr ([lsearch $classMacros $value] != -1) || $isClassMacroByRegexp]
|
|
|
}
|
|
|
|
|
|
proc isCppType {type value} {
|
|
|
set cppTypes {
|
|
|
"bool"
|
|
|
"char"
|
|
|
"int"
|
|
|
"float"
|
|
|
"double"
|
|
|
"void"
|
|
|
"wchart"
|
|
|
"identifier"
|
|
|
}
|
|
|
|
|
|
set valueIsClassMacro 0
|
|
|
if {$type == "identifier"} {
|
|
|
set valueIsClassMacro [isClassMacro $value]
|
|
|
}
|
|
|
|
|
|
return [expr ([lsearch $cppTypes $type] != -1) && !$valueIsClassMacro]
|
|
|
}
|
|
|
|
|
|
set tokenFilter {
|
|
|
using
|
|
|
namespace
|
|
|
class
|
|
|
struct
|
|
|
enum
|
|
|
typedef
|
|
|
pp_define
|
|
|
leftbrace
|
|
|
rightbrace
|
|
|
leftparen
|
|
|
rightparen
|
|
|
leftbracket
|
|
|
rightbracket
|
|
|
semicolon
|
|
|
colon_colon
|
|
|
colon
|
|
|
comma
|
|
|
dot
|
|
|
arrow
|
|
|
assign
|
|
|
static
|
|
|
const
|
|
|
identifier
|
|
|
bool
|
|
|
char
|
|
|
int
|
|
|
float
|
|
|
double
|
|
|
void
|
|
|
wchart
|
|
|
return
|
|
|
operator
|
|
|
less
|
|
|
greater
|
|
|
}
|
|
|
|
|
|
foreach fileName [getSourceFileNames] {
|
|
|
set machines [list]
|
|
|
|
|
|
# Check the functions at the root of the file
|
|
|
lappend machines [createMachine "method" "root"]
|
|
|
|
|
|
# Check static const variables at the root of the file
|
|
|
lappend machines [createMachine "memberVariable" "root"]
|
|
|
|
|
|
set lastIdentifier ""
|
|
|
set lastIdentifier2 ""
|
|
|
set prev1 ""
|
|
|
set prev2 ""
|
|
|
set insideFunctionParameters 0
|
|
|
set insideFunction 0
|
|
|
foreach token [getTokens $fileName 1 0 -1 -1 $tokenFilter] {
|
|
|
set type [lindex $token 3]
|
|
|
set line [lindex $token 1]
|
|
|
|
|
|
# Retrieve identifier value
|
|
|
if {$type == "identifier"} {
|
|
|
set lastIdentifier2 $lastIdentifier
|
|
|
set lastIdentifier [lindex $token 0]
|
|
|
}
|
|
|
|
|
|
if {$type == "namespace"} {
|
|
|
# Look for the functions in the namespace to check the local variables
|
|
|
lappend machines [createMachine "method" "beforeLeftBrace"]
|
|
|
# Check the static const variables inside this namespace
|
|
|
lappend machines [createMachine "memberVariable" "beforeLeftBrace"]
|
|
|
} elseif {$type == "class" || ($type == "struct" && !$insideFunctionParameters)} {
|
|
|
# Look for the functions in the class/struct to check the local variables
|
|
|
lappend machines [createMachine "method" "beforeLeftBrace"]
|
|
|
# Check the static const variables inside this namespace
|
|
|
set m [createMachine "memberVariable" "beforeLeftBrace"]
|
|
|
dict set m isInClass 1
|
|
|
dict set m classOrStruct $type
|
|
|
lappend machines $m
|
|
|
}
|
|
|
|
|
|
set machinesToKeep [list]
|
|
|
foreach m $machines {
|
|
|
set keepMachine 1
|
|
|
dict with m {
|
|
|
# Method
|
|
|
if {$name == "method"} {
|
|
|
if {$state == "beforeLeftBrace"} {
|
|
|
if {$type == "leftbrace"} {
|
|
|
set state "root"
|
|
|
} elseif {$type == "semicolon"} {
|
|
|
set keepMachine 0
|
|
|
}
|
|
|
} elseif {$state == "root"} {
|
|
|
if {[isCppType $prev2 $lastIdentifier2] && $prev1 == "identifier" && $type == "leftparen"} {
|
|
|
# Check the local variables inside this function
|
|
|
set insideFunctionParameters 1
|
|
|
set insideFunction 1
|
|
|
lappend machinesToKeep [createMachine "localVariable" "beforeLeftBrace"]
|
|
|
|
|
|
} elseif {$type == "leftbrace"} {
|
|
|
set state "consumeBraces"
|
|
|
incr bracesCounter
|
|
|
} elseif {$type == "rightbrace"} {
|
|
|
# End of the state machine
|
|
|
set keepMachine 0
|
|
|
}
|
|
|
} elseif {$state == "consumeBraces"} {
|
|
|
if {$type == "leftbrace"} {
|
|
|
incr bracesCounter
|
|
|
} elseif {$type == "rightbrace"} {
|
|
|
incr bracesCounter -1
|
|
|
if {$bracesCounter == 0} {
|
|
|
set state "root"
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
# Local variables
|
|
|
if {$name == "localVariable"} {
|
|
|
if {$state == "beforeLeftBrace"} {
|
|
|
if {$type == "less"} {
|
|
|
set previousState $state
|
|
|
set state "consumeAngleBracket"
|
|
|
incr angleBracketCounter
|
|
|
} elseif {[isCppType $prev2 $lastIdentifier2] && $prev1 == "identifier" && ($type == "comma" || $type == "assign" || $type == "rightparen" || $type == "leftbracket")} {
|
|
|
# Check function parameters
|
|
|
if {![regexp $localVariableRegex $lastIdentifier]} {
|
|
|
report $fileName $line "The method parameter names should match the following regex: $localVariableRegex (found: $lastIdentifier)"
|
|
|
}
|
|
|
} elseif {$type == "leftbrace"} {
|
|
|
set insideFunctionParameters 0
|
|
|
set state "root"
|
|
|
} elseif {$type == "semicolon"} {
|
|
|
# End of the state machine
|
|
|
set insideFunctionParameters 0
|
|
|
set insideFunction 0
|
|
|
set keepMachine 0
|
|
|
}
|
|
|
} elseif {$state == "root"} {
|
|
|
if {$type == "leftbrace"} {
|
|
|
incr bracesCounter
|
|
|
} elseif {$type == "rightbrace"} {
|
|
|
if {$bracesCounter > 0} {
|
|
|
incr bracesCounter -1
|
|
|
} else {
|
|
|
# End of the state machine
|
|
|
set insideFunctionParameters 0
|
|
|
set insideFunction 0
|
|
|
set keepMachine 0
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if {[isCppType $prev2 $lastIdentifier2] && $prev1 == "identifier" && ($type == "assign" || $type == "semicolon" || $type == "leftparen" || $type == "leftbracket")} {
|
|
|
# Check local variable
|
|
|
if {![regexp $localVariableRegex $lastIdentifier]} {
|
|
|
report $fileName $line "The local variable names should match the following regex: $localVariableRegex (found: $lastIdentifier)"
|
|
|
}
|
|
|
}
|
|
|
} elseif {$state == "consumeBracket"} {
|
|
|
if {$type == "leftbracket"} {
|
|
|
incr bracketCounter
|
|
|
} elseif {$type == "rightbracket"} {
|
|
|
incr bracketCounter -1
|
|
|
if {$bracketCounter == 0} {
|
|
|
set state $previousState
|
|
|
}
|
|
|
}
|
|
|
} elseif {$state == "consumeAngleBracket"} {
|
|
|
if {$type == "less"} {
|
|
|
incr angleBracketCounter
|
|
|
} elseif {$type == "greater"} {
|
|
|
incr angleBracketCounter -1
|
|
|
if {$angleBracketCounter == 0} {
|
|
|
set state $previousState
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if {$state != "consumeBracket" && $type == "leftbracket"} {
|
|
|
set previousState $state
|
|
|
set state "consumeBracket"
|
|
|
incr bracketCounter
|
|
|
}
|
|
|
}
|
|
|
|
|
|
# Member and const variables
|
|
|
if {$name == "memberVariable"} {
|
|
|
if {$state == "beforeLeftBrace"} {
|
|
|
if {$type == "leftbrace"} {
|
|
|
set state "root"
|
|
|
} elseif {$type == "semicolon"} {
|
|
|
set keepMachine 0
|
|
|
}
|
|
|
} elseif {$state == "root"} {
|
|
|
# is/isn't var
|
|
|
if {$type == "using" || $type == "class" || $type == "struct"} {
|
|
|
set isVar 0
|
|
|
} elseif {$type == "typedef"} {
|
|
|
set isTypedef 1
|
|
|
}
|
|
|
|
|
|
# static/const
|
|
|
if {$type == "static"} {
|
|
|
set isStatic 1
|
|
|
} elseif {$type == "const"} {
|
|
|
set isConst 1
|
|
|
}
|
|
|
|
|
|
if {$isVar && !$isTypedef && $prev1 == "pp_define" && $type == "identifier"} {
|
|
|
# Check defines
|
|
|
if {![regexp $constVarRegex $lastIdentifier]} {
|
|
|
report $fileName $line "The constant names should match the following regex: $constVarRegex (found: $lastIdentifier)"
|
|
|
}
|
|
|
} elseif {$isVar && !$isTypedef && $prev1 == "identifier" && ($type == "assign" || $type == "semicolon" || $type == "leftbracket")} {
|
|
|
# Check member variables
|
|
|
# Appart from the const, we don't check the member variables outside
|
|
|
# of their classes to avoid false positive
|
|
|
if {((!$isInClass && $isConst) || ($isInClass && $isStatic && $isConst)) && ![regexp $constVarRegex $lastIdentifier]} {
|
|
|
report $fileName $line "The constant names should match the following regex: $constVarRegex (found: $lastIdentifier)"
|
|
|
} elseif {$isInClass && $isStatic && !$isConst && ![regexp $staticMemberVariableRegex $lastIdentifier]} {
|
|
|
report $fileName $line "The static member variable names should match the following regex: $staticMemberVariableRegex (found: $lastIdentifier)"
|
|
|
} elseif {$isInClass && !$isStatic} {
|
|
|
if {$classOrStruct == "class" && ![regexp $classMemberVariableRegex $lastIdentifier]} {
|
|
|
report $fileName $line "The class member variable names should match the following regex: $classMemberVariableRegex (found: $lastIdentifier)"
|
|
|
} elseif {$classOrStruct == "struct" && ![regexp $structMemberVariableRegex $lastIdentifier] && ![regexp $classMemberVariableRegex $lastIdentifier]} {
|
|
|
report $fileName $line "The struct member variable names should match the following regex: $structMemberVariableRegex or the class member regex: $classMemberVariableRegex (found: $lastIdentifier)"
|
|
|
}
|
|
|
}
|
|
|
} elseif {$type == "leftbrace"} {
|
|
|
set state "consumeBraces"
|
|
|
incr bracesCounter
|
|
|
} elseif {$type == "leftparen"} {
|
|
|
set state "consumeParen"
|
|
|
incr parenCounter
|
|
|
} elseif {$type == "rightbrace"} {
|
|
|
# End of the state machine
|
|
|
set keepMachine 0
|
|
|
}
|
|
|
|
|
|
if {$type == "leftbracket"} {
|
|
|
incr bracketCounter
|
|
|
set state "consumeBracket"
|
|
|
}
|
|
|
|
|
|
# Reinit static, const and isVar
|
|
|
if {$type == "assign" || $type == "semicolon" || $type == "leftbrace"} {
|
|
|
set isStatic 0
|
|
|
set isConst 0
|
|
|
set isVar 1
|
|
|
}
|
|
|
|
|
|
if {$type == "semicolon"} {
|
|
|
set isTypedef 0
|
|
|
}
|
|
|
} elseif {$state == "consumeBraces"} {
|
|
|
if {$type == "leftbrace"} {
|
|
|
incr bracesCounter
|
|
|
} elseif {$type == "rightbrace"} {
|
|
|
incr bracesCounter -1
|
|
|
if {$bracesCounter == 0} {
|
|
|
set state "root"
|
|
|
}
|
|
|
}
|
|
|
} elseif {$state == "consumeParen"} {
|
|
|
if {$type == "leftparen"} {
|
|
|
incr parenCounter
|
|
|
} elseif {$type == "rightparen"} {
|
|
|
incr parenCounter -1
|
|
|
if {$parenCounter == 0} {
|
|
|
set state "root"
|
|
|
}
|
|
|
}
|
|
|
} elseif {$state == "consumeBracket"} {
|
|
|
if {$type == "leftbracket"} {
|
|
|
incr bracketCounter
|
|
|
} elseif {$type == "rightbracket"} {
|
|
|
incr bracketCounter -1
|
|
|
if {$bracketCounter == 0} {
|
|
|
set state "root"
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if {$keepMachine} {
|
|
|
lappend machinesToKeep $m
|
|
|
}
|
|
|
}
|
|
|
set machines $machinesToKeep
|
|
|
|
|
|
set prev2 $prev1
|
|
|
set prev1 $type
|
|
|
}
|
|
|
}
|
|
|
|
