HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r2:451739a45362

Ajout de vera++

perrinel -

r2:451739a45362

parent child

Context file:

r2:451739a45362

formatting/cmake/Findvera++.cmake created 644 +52 0

			@@ -0,0 +1,52
		1	# - try to find vera++ tool
		2	#
		3	# Cache Variables:
		4	# VERA++_ROOT_DIR
		5	# VERA++_EXECUTABLE
		6	# VERA++_USE_FILE
		7	#
		8	# Non-cache variables you might use in your CMakeLists.txt:
		9	# VERA++_FOUND
		10	#
		11	# Requires these CMake modules:
		12	# FindPackageHandleStandardArgs (known included with CMake >=2.6.2)
		13
		14	file(TO_CMAKE_PATH "${VERA++_ROOT_DIR}" VERA++_ROOT_DIR)
		15	set(VERA++_ROOT_DIR
		16	"${VERA++_ROOT_DIR}"
		17	CACHE
		18	PATH
		19	"Path to search for vera++")
		20
		21	if(VERA++_EXECUTABLE AND NOT EXISTS "${VERA++_EXECUTABLE}")
		22	set(VERA++_EXECUTABLE "notfound" CACHE PATH FORCE "")
		23	endif()
		24
		25	# If we have a custom path, look there first.
		26	if(VERA++_ROOT_DIR)
		27	find_program(VERA++_EXECUTABLE
		28	NAMES
		29	vera++
		30	PATHS
		31	"${VERA++_ROOT_DIR}"
		32	PATH_SUFFIXES
		33	bin
		34	NO_DEFAULT_PATH)
		35	endif()
		36
		37	find_program(VERA++_EXECUTABLE NAMES vera++)
		38
		39	# Find the use file for vera
		40	GET_FILENAME_COMPONENT(VERA++_MODULE_DIR ${CMAKE_CURRENT_LIST_FILE} PATH)
		41	SET(VERA++_USE_FILE "${VERA++_MODULE_DIR}/use_vera++.cmake")
		42
		43	SET(VERA++_ALL ${VERA++_EXECUTABLE} ${VERA++_USE_FILE})
		44
		45	include(FindPackageHandleStandardArgs)
		46	find_package_handle_standard_args(vera++
		47	DEFAULT_MSG
		48	VERA++_ALL
		49	VERA++_EXECUTABLE
		50	VERA++_USE_FILE)
		51
		52	mark_as_advanced(VERA++_EXECUTABLE)

formatting/cmake/use_vera++.cmake created 644 +342 0

			@@ -0,0 +1,342
		1	#
		2	# use_vera++.cmake
		3	#
		4	# The following functions are defined in this document:
		5	# - ADD_VERA_TARGETS
		6	# - ADD_VERA_CHECKSTYLE_TARGET
		7	#
		8
		9	# ADD_VERA_TARGETS(<globExpression> ...
		10	# [ADD_TO_ALL]
		11	# [NAME <name>]
		12	# [NAME_ALL <nameall>]
		13	# [ROOT <directory>]
		14	# [PROFILE <profile>]
		15	# [RECURSE]
		16	# [EXCLUSION <exclusionFile> ...]
		17	# [PARAMETER <name>=<value> ...]
		18	# [PARAMETERFILE <parameterFile> ...])
		19	#
		20	# Two custom targets will be created:
		21	# * style_reports is run as part of the build, and is not rerun unless one of
		22	# the file checked is modified (only created if ADD_TO_ALL is provided);
		23	# * style must be explicitely called (make style) and is rerun even if the files
		24	# to check have not been modified. To achieve this behavior, the commands used
		25	# in this target pretend to produce a file without actually producing it.
		26	# Because the output file is not there after the run, the command will be rerun
		27	# again at the next target build.
		28	# The report style is selected based on the build environment, so the style
		29	# problems are properly reported in the IDEs
		30	#
		31	# If ADD_TO_ALL is provided then a target will be added to the default build
		32	# targets so that each time a source file is compiled, it is analyzed with
		33	# vera++.
		34	#
		35	# NAME and NAME_ALL customize the name of the targets (style and style_reports
		36	# by default respectively).
		37	#
		38	# ROOT set the vera++ root directory, containing the rules and profiles (default
		39	# to the current binary directory).
		40	#
		41	# PROFILE selects the vera++ profile to use (default to "default").
		42	#
		43	# RECURSE selects if the glob expressions should be applied recursively or not.
		44	#
		45	# EXCLUSION list of vera++ exclusion files. Can be used several times.
		46	#
		47	# PARAMETER list of vera++ parameters (name=value). Can be used several times.
		48	#
		49	# PARAMETERFILE list of vera++ parameter files. Can be used several times.
		50	function(add_vera_targets)
		51	# default values
		52	set(target "style")
		53	set(target_all "style_reports")
		54	set(profile "default")
		55	set(root "${CMAKE_CURRENT_BINARY_DIR}")
		56	set(exclusions)
		57	set(parameters)
		58	set(parameterFiles)
		59	set(recurse OFF)
		60	set(addToAll OFF)
		61	set(globs)
		62	# parse the options
		63	math(EXPR lastIdx "${ARGC} - 1")
		64	set(i 0)
		65	while(i LESS ${ARGC})
		66	set(arg "${ARGV${i}}")
		67	if("${arg}" STREQUAL "ADD_TO_ALL")
		68	set(addToAll ON)
		69	elseif("${arg}" STREQUAL "NAME")
		70	vera_incr(i)
		71	set(target "${ARGV${i}}")
		72	elseif("${arg}" STREQUAL "NAME_ALL")
		73	vera_incr(i)
		74	set(target_all "${ARGV${i}}")
		75	elseif("${arg}" STREQUAL "ROOT")
		76	vera_incr(i)
		77	set(root "${ARGV${i}}")
		78	elseif("${arg}" STREQUAL "PROFILE")
		79	vera_incr(i)
		80	set(profile "${ARGV${i}}")
		81	elseif("${arg}" STREQUAL "EXCLUSION")
		82	vera_incr(i)
		83	list(APPEND exclusions --exclusions "${ARGV${i}}")
		84	elseif("${arg}" STREQUAL "RECURSE")
		85	set(recurse ON)
		86	elseif("${arg}" STREQUAL "PARAMETER")
		87	vera_incr(i)
		88	list(APPEND parameters --parameter "${ARGV${i}}")
		89	elseif("${arg}" STREQUAL "PARAMETERFILE")
		90	vera_incr(i)
		91	list(APPEND parameterFiles --parameters "${ARGV${i}}")
		92	else()
		93	list(APPEND globs ${arg})
		94	endif()
		95	vera_incr(i)
		96	endwhile()
		97
		98	if(recurse)
		99	file(GLOB_RECURSE srcs ${globs})
		100	else()
		101	file(GLOB srcs ${globs})
		102	endif()
		103	list(SORT srcs)
		104
		105	if(NOT VERA++_EXECUTABLE AND TARGET vera)
		106	set(vera_program "$<TARGET_FILE:vera>")
		107	else()
		108	set(vera_program "${VERA++_EXECUTABLE}")
		109	endif()
		110
		111	# Two custom targets will be created:
		112	# * style_reports is run as part of the build, and is not rerun unless one of
		113	# the file checked is modified;
		114	# * style must be explicitely called (make style) and is rerun even if the files
		115	# to check have not been modified. To achieve this behavior, the commands used
		116	# in this target pretend to produce a file without actually producing it.
		117	# Because the output file is not there after the run, the command will be rerun
		118	# again at the next target build.
		119	# The report style is selected based on the build environment, so the style
		120	# problems are properly reported in the IDEs
		121	if(MSVC)
		122	set(style vc)
		123	else()
		124	set(style std)
		125	endif()
		126	set(xmlreports)
		127	set(noreports)
		128	set(reportNb 0)
		129	set(reportsrcs)
		130	list(GET srcs 0 first)
		131	get_filename_component(currentDir ${first} PATH)
		132	# add a fake src file in a fake dir to trigger the creation of the last
		133	# custom command
		134	list(APPEND srcs "#12345678900987654321#/0987654321#1234567890")
		135	# Create the directory where the reports will be saved
		136	SET(reportDirectory "${CMAKE_CURRENT_BINARY_DIR}/vera")
		137	FILE(MAKE_DIRECTORY ${reportDirectory})
		138	foreach(s ${srcs})
		139	get_filename_component(d ${s} PATH)
		140	if(NOT "${d}" STREQUAL "${currentDir}")
		141	# this is a new dir - lets generate everything needed for the previous dir
		142	string(LENGTH "${CMAKE_SOURCE_DIR}" len)
		143	string(SUBSTRING "${currentDir}" 0 ${len} pre)
		144	if("${pre}" STREQUAL "${CMAKE_SOURCE_DIR}")
		145	string(SUBSTRING "${currentDir}" ${len} -1 currentDir)
		146	string(REGEX REPLACE "^/" "" currentDir "${currentDir}")
		147	endif()
		148	if("${currentDir}" STREQUAL "")
		149	set(currentDir ".")
		150	endif()
		151	set(xmlreport ${reportDirectory}/vera_report_${reportNb}.xml)
		152	if(addToAll)
		153	add_custom_command(
		154	OUTPUT ${xmlreport}
		155	COMMAND ${vera_program}
		156	--root ${root}
		157	--profile ${profile}
		158	--${style}-report=-
		159	--show-rule
		160	--warning
		161	--xml-report=${xmlreport}
		162	${exclusions}
		163	${parameters}
		164	${parameterFiles}
		165	${reportsrcs}
		166	DEPENDS ${reportsrcs}
		167	COMMENT "Checking style with vera++ in ${currentDir}"
		168	)
		169	endif()
		170
		171	set(noreport ${reportDirectory}/vera_noreport_${reportNb}.xml)
		172	add_custom_command(
		173	OUTPUT ${noreport}
		174	COMMAND ${vera_program}
		175	--root ${root}
		176	--profile ${profile}
		177	--${style}-report=-
		178	--show-rule
		179	--warning
		180	# --xml-report=${noreport}
		181	${exclusions}
		182	${parameters}
		183	${parameterFiles}
		184	${reportsrcs}
		185	DEPENDS ${reportsrcs}
		186	COMMENT "Checking style with vera++ in ${currentDir}"
		187	)
		188
		189	list(APPEND xmlreports ${xmlreport})
		190	list(APPEND noreports ${noreport})
		191	vera_incr(reportNb)
		192	# clear the list for the next dir
		193	set(reportsrcs)
		194	set(currentDir ${d})
		195	endif()
		196	list(APPEND reportsrcs ${s})
		197	endforeach()
		198	# Create the custom targets that will trigger the custom command created
		199	# previously
		200	if(addToAll)
		201	add_custom_target(${target_all} ALL DEPENDS ${xmlreports})
		202	endif()
		203	add_custom_target(${target} DEPENDS ${noreports})
		204	endfunction()
		205
		206
		207	# ADD_VERA_CHECKSTYLE_TARGET(<globExpression> ...
		208	# [NAME <name>]
		209	# [ROOT <directory>]
		210	# [PROFILE <profile>]
		211	# [RECURSE]
		212	# [EXCLUSION <exclusionFile> ...]
		213	# [PARAMETER <name>=<value> ...]
		214	# [PARAMETERFILE <parameterFile> ...])
		215	#
		216	# The checkstyle custom target will be created. This target runs vera++ and
		217	# create checkstyle reports in the ${CMAKE_CURRENT_BINARY_DIR}/checkstyle
		218	# directory.
		219	#
		220	# NAME customize the name of the target (checkstyle by default).
		221	#
		222	# ROOT set the vera++ root directory, containing the rules and profiles (default
		223	# to the current binary directory).
		224	#
		225	# PROFILE selects the vera++ profile to use (default to "default").
		226	#
		227	# RECURSE selects if the glob expressions should be applied recursively or not.
		228	#
		229	# EXCLUSION list of vera++ exclusion files. Can be used several times.
		230	#
		231	# PARAMETER list of vera++ parameters (name=value). Can be used several times.
		232	#
		233	# PARAMETERFILE list of vera++ parameter files. Can be used several times.
		234	function(add_vera_checkstyle_target)
		235	# default values
		236	set(target "checkstyle")
		237	set(profile "default")
		238	set(root "${CMAKE_CURRENT_BINARY_DIR}")
		239	set(exclusions)
		240	set(parameters)
		241	set(parameterFiles)
		242	set(recurse OFF)
		243	set(globs)
		244	# parse the options
		245	math(EXPR lastIdx "${ARGC} - 1")
		246	set(i 0)
		247	while(i LESS ${ARGC})
		248	set(arg "${ARGV${i}}")
		249	if("${arg}" STREQUAL "NAME")
		250	vera_incr(i)
		251	set(target "${ARGV${i}}")
		252	elseif("${arg}" STREQUAL "ROOT")
		253	vera_incr(i)
		254	set(root "${ARGV${i}}")
		255	elseif("${arg}" STREQUAL "PROFILE")
		256	vera_incr(i)
		257	set(profile "${ARGV${i}}")
		258	elseif("${arg}" STREQUAL "EXCLUSION")
		259	vera_incr(i)
		260	list(APPEND exclusions --exclusions "${ARGV${i}}")
		261	elseif("${arg}" STREQUAL "RECURSE")
		262	set(recurse ON)
		263	elseif("${arg}" STREQUAL "PARAMETER")
		264	vera_incr(i)
		265	list(APPEND parameters --parameter "${ARGV${i}}")
		266	elseif("${arg}" STREQUAL "PARAMETERFILE")
		267	vera_incr(i)
		268	list(APPEND parameterFiles --parameters "${ARGV${i}}")
		269	else()
		270	list(APPEND globs ${arg})
		271	endif()
		272	vera_incr(i)
		273	endwhile()
		274
		275	if(recurse)
		276	file(GLOB_RECURSE srcs ${globs})
		277	else()
		278	file(GLOB srcs ${globs})
		279	endif()
		280	list(SORT srcs)
		281
		282	if(NOT VERA++_EXECUTABLE AND TARGET vera)
		283	set(vera_program "$<TARGET_FILE:vera>")
		284	else()
		285	set(vera_program "${VERA++_EXECUTABLE}")
		286	endif()
		287
		288	set(checkstylereports)
		289	set(reportNb 0)
		290	set(reportsrcs)
		291	list(GET srcs 0 first)
		292	get_filename_component(currentDir ${first} PATH)
		293	# add a fake src file in a fake dir to trigger the creation of the last
		294	# custom command
		295	list(APPEND srcs "#12345678900987654321#/0987654321#1234567890")
		296	# Create the directory where the reports will be saved
		297	SET(checkstyleDirectory "${CMAKE_CURRENT_BINARY_DIR}/checkstyle")
		298	FILE(MAKE_DIRECTORY ${checkstyleDirectory})
		299	foreach(s ${srcs})
		300	get_filename_component(d ${s} PATH)
		301	if(NOT "${d}" STREQUAL "${currentDir}")
		302	# this is a new dir - lets generate everything needed for the previous dir
		303	string(LENGTH "${CMAKE_SOURCE_DIR}" len)
		304	string(SUBSTRING "${currentDir}" 0 ${len} pre)
		305	if("${pre}" STREQUAL "${CMAKE_SOURCE_DIR}")
		306	string(SUBSTRING "${currentDir}" ${len} -1 currentDir)
		307	string(REGEX REPLACE "^/" "" currentDir "${currentDir}")
		308	endif()
		309	if("${currentDir}" STREQUAL "")
		310	set(currentDir ".")
		311	endif()
		312	set(checkstylereport ${checkstyleDirectory}/vera_checkstylereport_${reportNb}.xml)
		313	add_custom_command(
		314	OUTPUT ${checkstylereport}
		315	COMMAND ${vera_program}
		316	--root ${root}
		317	--profile ${profile}
		318	--show-rule
		319	--checkstyle-report ${checkstylereport}
		320	${exclusions}
		321	${parameters}
		322	${parameterFiles}
		323	${reportsrcs}
		324	DEPENDS ${reportsrcs}
		325	COMMENT "Checking style with vera++ in ${currentDir}"
		326	)
		327	list(APPEND checkstylereports ${checkstylereport})
		328	vera_incr(reportNb)
		329	# clear the list for the next dir
		330	set(reportsrcs)
		331	set(currentDir ${d})
		332	endif()
		333	list(APPEND reportsrcs ${s})
		334	endforeach()
		335	# Create the custom targets that will trigger the custom command created
		336	# previously
		337	add_custom_target(${target} DEPENDS ${checkstylereports})
		338	endfunction()
		339
		340	macro(vera_incr var_name)
		341	math(EXPR ${var_name} "${${var_name}} + 1")
		342	endmacro()

formatting/vera-root/profiles/default created 644 +26 0

			@@ -0,0 +1,26
		1	#!/usr/bin/tclsh
		2	# This file defines the set of scripts (rules) that should be executed
		3	# by default (if no specific profile is named when vera++ is launched).
		4
		5	set rules {
		6	IPSIS_F11
		7	IPSIS_F13
		8
		9	IPSIS_S01
		10	IPSIS_S02
		11	IPSIS_S03
		12	IPSIS_S04_FILENAME
		13	IPSIS_S04_NAMESPACE
		14	IPSIS_S04_CLASS
		15	IPSIS_S04_ENUM
		16	IPSIS_S04_TYPEDEF
		17	IPSIS_S04_METHOD
		18	IPSIS_S04_VARIABLE
		19	IPSIS_S05
		20	IPSIS_S06
		21	IPSIS_S09
		22
		23	IPSIS_C01
		24	IPSIS_C09
		25	IPSIS_C11
		26	}

formatting/vera-root/profiles/sciqlop created 644 +26 0

			@@ -0,0 +1,26
		1	#!/usr/bin/tclsh
		2	# This file defines the set of scripts (rules) that should be executed for a
		3	# default IPSIS project.
		4
		5	set rules {
		6	IPSIS_F11
		7	IPSIS_F13
		8
		9	IPSIS_S01
		10	IPSIS_S02
		11	IPSIS_S03
		12	IPSIS_S04_FILENAME
		13	IPSIS_S04_NAMESPACE
		14	IPSIS_S04_CLASS
		15	IPSIS_S04_ENUM
		16	IPSIS_S04_TYPEDEF
		17	IPSIS_S04_METHOD
		18	IPSIS_S04_VARIABLE
		19	IPSIS_S05
		20	IPSIS_S06
		21	IPSIS_S09
		22
		23	IPSIS_C01
		24	IPSIS_C09
		25	IPSIS_C11
		26	}

formatting/vera-root/scripts/rules/DUMP.tcl created 644 +13 0

			@@ -0,0 +1,13
		1	#!/usr/bin/tclsh
		2	foreach f [getSourceFileNames] {
		3	puts "Tokens in file ${f}:"
		4	foreach t [getTokens $f 1 0 -1 -1 {}] {
		5	set value [lindex $t 0]
		6	set line [lindex $t 1]
		7	set column [lindex $t 2]
		8	set name [lindex $t 3]
		9
		10	puts "${line}/${column}\t${name}\t${value}"
		11	}
		12	puts ""
		13	}

formatting/vera-root/scripts/rules/IPSIS_C01.tcl created 644 +65 0

			@@ -0,0 +1,65
		1	#!/usr/bin/tclsh
		2	# The destructor of a class should be virtual
		3
		4	proc createMachine {initState} {
		5	set machine [dict create state $initState bracesCounter 0]
		6	return $machine
		7	}
		8
		9	foreach fileName [getSourceFileNames] {
		10	set machines [list]
		11
		12	set prev1 ""
		13	set prev2 ""
		14	foreach token [getTokens $fileName 1 0 -1 -1 {class struct leftbrace rightbrace virtual compl identifier semicolon}] {
		15	set type [lindex $token 3]
		16	set line [lindex $token 1]
		17
		18	if {$type == "class" \|\| $type == "struct"} {
		19	lappend machines [createMachine "beforeLeftBrace"]
		20	}
		21
		22	set machinesToKeep [list]
		23	foreach m $machines {
		24	set keepMachine 1
		25	dict with m {
		26	if {$state == "beforeLeftBrace"} {
		27	if {$type == "leftbrace"} {
		28	set state "root"
		29	} elseif {$type == "semicolon"} {
		30	set keepMachine 0
		31	}
		32	} elseif {$state == "root"} {
		33	if {$prev2 != "virtual" && $prev1 == "compl" && $type == "identifier"} {
		34	set dtorName [lindex $token 0]
		35	report $fileName $line "The destructor ~${dtorName}() of the class should be virtual"
		36	}
		37
		38	if {$type == "leftbrace"} {
		39	incr bracesCounter
		40	set state "consumeBraces"
		41	} elseif {$type == "rightbrace"} {
		42	set keepMachine 0
		43	}
		44	} elseif {$state == "consumeBraces"} {
		45	if {$type == "leftbrace"} {
		46	incr bracesCounter
		47	} elseif {$type == "rightbrace"} {
		48	incr bracesCounter -1
		49	if {$bracesCounter == 0} {
		50	set state "root"
		51	}
		52	}
		53	}
		54	}
		55
		56	if {$keepMachine} {
		57	lappend machinesToKeep $m
		58	}
		59	}
		60	set machines $machinesToKeep
		61
		62	set prev2 $prev1
		63	set prev1 $type
		64	}
		65	}

formatting/vera-root/scripts/rules/IPSIS_C09.tcl created 644 +23 0

			@@ -0,0 +1,23
		1	#!/usr/bin/tclsh
		2	# using namespace are not allowed in header files
		3
		4	foreach fileName [getSourceFileNames] {
		5	set extension [file extension $fileName]
		6	if {[lsearch {.h .hh .hpp .hxx .ipp} $extension] != -1} {
		7
		8	set state "start"
		9	foreach token [getTokens $fileName 1 0 -1 -1 {using namespace identifier}] {
		10	set type [lindex $token 3]
		11
		12	if {$state == "using" && $type == "namespace"} {
		13	report $fileName $usingLine "using namespace not allowed in header file"
		14	}
		15
		16	if {$type == "using"} {
		17	set usingLine [lindex $token 1]
		18	}
		19
		20	set state $type
		21	}
		22	}
		23	}

formatting/vera-root/scripts/rules/IPSIS_C11.tcl created 644 +103 0

			@@ -0,0 +1,103
		1	#!/usr/bin/tclsh
		2	# Exceptions should be thrown by value and catched by reference.
		3	# Moreover a rethrow must be done with throw;
		4
		5	proc createThrowMachine {line initState} {
		6	set machine [dict create name "throw" keywordLine $line state $initState bracesCounter 0 firstKeyword ""]
		7	return $machine
		8	}
		9
		10	proc createCatchMachine {line initState} {
		11	set machine [dict create name "catch" keywordLine $line state $initState bracesCounter 0 catchedException ""]
		12	return $machine
		13	}
		14
		15	foreach fileName [getSourceFileNames] {
		16	set machines [list]
		17
		18	set lastIdentifier ""
		19	set prev1 ""
		20	set prev2 ""
		21	set prev3 ""
		22	foreach token [getTokens $fileName 1 0 -1 -1 {throw catch new leftbrace rightbrace greater and identifier rightparen semicolon}] {
		23	set type [lindex $token 3]
		24	set line [lindex $token 1]
		25
		26	if {$type == "identifier"} {
		27	set lastIdentifier [lindex $token 0]
		28	}
		29
		30	if {$type == "throw"} {
		31	lappend machines [createThrowMachine $line "beforeThrow"]
		32	} elseif {$type == "catch"} {
		33	lappend machines [createCatchMachine $line "waitingForLeftBrace"]
		34	}
		35
		36	set machinesToKeep [list]
		37	foreach m $machines {
		38	set keepMachine 1
		39	dict with m {
		40	if {$name == "throw"} {
		41	if {$state == "beforeThrow" && $type == "throw"} {
		42	set state "catchFirstKeyword"
		43	} elseif {$state == "catchFirstKeyword"} {
		44	if {$type == "semicolon"} {
		45	# This is a rethrow
		46	set keepMachine 0
		47	} else {
		48	set firstKeyword $type
		49	set state "waitForEndOfThrow"
		50	}
		51	} elseif {$state == "waitForEndOfThrow"} {
		52	if {$type == "leftbrace"} {
		53	# This is an exception specification
		54	set keepMachine 0
		55	} elseif {$type == "semicolon"} {
		56	# This is a throw, check that the first keyword isn't
		57	# new or &
		58	if {$firstKeyword == "new" \|\| $firstKeyword == "and"} {
		59	report $fileName $keywordLine "Exceptions should be thrown by value. Not allocated with new or dereferenced with &."
		60	}
		61	set keepMachine 0
		62	}
		63	}
		64	} elseif {$name == "catch"} {
		65	if {$state == "waitingForLeftBrace" && $type == "leftbrace"} {
		66	set state "insideCatch"
		67
		68	if {$prev2 == "identifier" && $prev1 == "rightparen"} {
		69	set catchedException $lastIdentifier
		70
		71	if {$prev3 != "and"} {
		72	report $fileName $keywordLine "Exceptions should be catched by reference (exception catched: $catchedException)"
		73	}
		74	}
		75	} elseif {$state == "insideCatch"} {
		76	if {$type == "leftbrace"} {
		77	incr bracesCounter
		78	} elseif {$type == "rightbrace"} {
		79	if {$bracesCounter > 0} {
		80	incr bracesCounter -1
		81	} else {
		82	set keepMachine 0
		83	}
		84	} elseif {$prev2 == "throw" && $prev1 == "identifier" && $type == "semicolon"} {
		85	if {$lastIdentifier == $catchedException} {
		86	report $fileName $line "Exceptions should be rethrown with 'throw;' instead of 'throw ${catchedException};'"
		87	}
		88	}
		89	}
		90	}
		91	}
		92
		93	if {$keepMachine} {
		94	lappend machinesToKeep $m
		95	}
		96	}
		97	set machines $machinesToKeep
		98
		99	set prev3 $prev2
		100	set prev2 $prev1
		101	set prev1 $type
		102	}
		103	}

formatting/vera-root/scripts/rules/IPSIS_F11.tcl created 644 +39 0

			@@ -0,0 +1,39
		1	#!/usr/bin/tclsh
		2	# control structures should have complete curly-braced block of code
		3
		4	foreach fileName [getSourceFileNames] {
		5
		6	set state "start"
		7	set prev ""
		8	foreach token [getTokens $fileName 1 0 -1 -1 {for if while do leftparen rightparen leftbrace rightbrace semicolon}] {
		9	set type [lindex $token 3]
		10
		11	if {$state == "control"} {
		12	if {$type == "leftparen"} {
		13	incr parenCount
		14	} elseif {$type == "rightparen"} {
		15	incr parenCount -1
		16	if {$parenCount == 0} {
		17	set state "expectedblock"
		18	}
		19	}
		20	} elseif {$state == "expectedblock"} {
		21	if {$type != "leftbrace"} {
		22	set line [lindex $token 1]
		23	report $fileName $line "full block {} expected in the control structure"
		24	}
		25	set state "block"
		26	}
		27
		28	if {$type == "for" \|\| $type == "if"} {
		29	set parenCount 0
		30	set state "control"
		31	} elseif {$type == "do"} {
		32	set state "expectedblock"
		33	} elseif {$type == "while" && $prev != "rightbrace"} {
		34	set parenCount 0
		35	set state "control"
		36	}
		37	set prev $type
		38	}
		39	}

formatting/vera-root/scripts/rules/IPSIS_F13.tcl created 644 +73 0

			@@ -0,0 +1,73
		1	#!/usr/bin/tclsh
		2	# namespace names should be recalled at the end of the namespace
		3	# namespace mynamespace {
		4	# } // mynamespace
		5
		6	proc createNamespaceDict {} {
		7	return [dict create state "waitingForIdentifier" identifier "" bracesCounter 0]
		8	}
		9
		10	foreach fileName [getSourceFileNames] {
		11
		12	set namespaces [list]
		13
		14	foreach token [getTokens $fileName 1 0 -1 -1 {namespace identifier leftbrace rightbrace semicolon cppcomment}] {
		15	set type [lindex $token 3]
		16
		17	set namespacesToKeep [list]
		18	foreach n $namespaces {
		19	set keepNamespace 1
		20	dict with n {
		21	if {$state == "waitingForIdentifier" && $type == "identifier"} {
		22	set state "waitingForLeftBrace"
		23	set identifier [lindex $token 0]
		24	} elseif {$state == "waitingForLeftBrace"} {
		25	if {$type == "semicolon"} {
		26	# Wasn't a namespace, remove the dict
		27	set keepNamespace 0
		28	} elseif {$type == "leftbrace"} {
		29	set bracesCounter 0
		30	set state "waitingForRightBrace"
		31	}
		32	} elseif {$state == "waitingForRightBrace"} {
		33	if {$type == "leftbrace"} {
		34	incr bracesCounter
		35	} elseif {$type == "rightbrace"} {
		36	if {$bracesCounter > 0} {
		37	incr bracesCounter -1
		38	} else {
		39	set state "waitingForComment"
		40	}
		41	}
		42	} elseif {$state == "waitingForComment"} {
		43	if {$type == "cppcomment"} {
		44	set commentValue [lindex $token 0]
		45	# Check that the comment report the namespace name
		46	if {![regexp "\\m$identifier\\M" $commentValue]} {
		47	set line [lindex $token 1]
		48	set commentValue [string trim $commentValue]
		49	report $fileName $line "The namespace $identifier should have been recalled in the comment here (// $identifier). Comment found: $commentValue"
		50	}
		51	} else {
		52	# There should have been a comment here
		53	set line [lindex $token 1]
		54	report $fileName $line "The namespace $identifier should have been recalled in a comment here (// $identifier)"
		55	}
		56	# Namespace processed, remove it from the list
		57	set keepNamespace 0
		58	}
		59	}
		60
		61	if {$keepNamespace} {
		62	lappend namespacesToKeep $n
		63	}
		64	}
		65	set namespaces $namespacesToKeep
		66
		67	# If the token is a namespace keyword, add a namespace dict for the next
		68	# foreach
		69	if {$type == "namespace"} {
		70	lappend namespaces [createNamespaceDict]
		71	}
		72	}
		73	}

formatting/vera-root/scripts/rules/IPSIS_S01.tcl created 644 +60 0

			@@ -0,0 +1,60
		1	#!/usr/bin/tclsh
		2	# At most one class per header file
		3
		4	foreach fileName [getSourceFileNames] {
		5	if {[regexp {(?:\\\|/)?([^\\/]+?)\.h$} $fileName matchedExpr expectedClassName]} {
		6	set state "waitingForClass"
		7	set alreadyOneClass 0
		8	set firstClassName ""
		9	set bracesCounter 0
		10
		11	set lastIdentifier ""
		12	foreach token [getTokens $fileName 1 0 -1 -1 {class identifier leftbrace rightbrace colon semicolon}] {
		13	set type [lindex $token 3]
		14
		15	if {$type == "identifier"} {
		16	set lastIdentifier [lindex $token 0]
		17	}
		18
		19	if {$state == "waitingForClass" && $type == "class"} {
		20	set state "waitingForBeginingOfClass"
		21	} elseif {$state == "waitingForBeginingOfClass"} {
		22	if {$type == "semicolon"} {
		23	set state "waitingForClass"
		24	} elseif {$type == "leftbrace" \|\| $type == "colon"} {
		25	# Check if this is the first class
		26	if {$alreadyOneClass} {
		27	set line [lindex $token 1]
		28	report $fileName $line "At most one public class can be defined in a header file. (class $lastIdentifier found but class $firstClassName already defined)"
		29	} else {
		30	set alreadyOneClass 1
		31	set firstClassName $lastIdentifier
		32
		33	# Check that the class has the same name than the file
		34	if {$lastIdentifier != $expectedClassName} {
		35	set line [lindex $token 1]
		36	report $fileName $line "The public class should have the same name than the header file. (class $lastIdentifier found but class $expectedClassName expected)"
		37	}
		38	}
		39	if {$type == "leftbrace"} {
		40	set state "waitingForEndOfClass"
		41	} else {
		42	set state "waitingForLeftBrace"
		43	}
		44	}
		45	} elseif {$state == "waitingForLeftBrace" && $type == "leftbrace"} {
		46	set state "waitingForEndOfClass"
		47	} elseif {$state == "waitingForEndOfClass"} {
		48	if {$type == "leftbrace"} {
		49	incr bracesCounter
		50	} elseif {$type == "rightbrace"} {
		51	if {$bracesCounter > 0} {
		52	incr bracesCounter -1
		53	} else {
		54	set state "waitingForClass"
		55	}
		56	}
		57	}
		58	}
		59	}
		60	}

formatting/vera-root/scripts/rules/IPSIS_S02.tcl created 644 +45 0

			@@ -0,0 +1,45
		1	#!/usr/bin/tclsh
		2	# The include guards should have the form PROJECT_FILENAME_H
		3
		4	set projectName [string toupper [getParameter "project-name" "PROJECTNAMENOTFOUND"]]
		5
		6	foreach fileName [getSourceFileNames] {
		7	if {[regexp {(?:\\\|/)?([^\\/]+?)\.h$} $fileName matchedExpr fileNameWithoutExt]} {
		8	set upperFileName [string toupper $fileNameWithoutExt]
		9	set expectedGuard "${projectName}_${upperFileName}_H"
		10
		11	set state "waitingForIfndef"
		12
		13	set firstInstruction 1
		14	set ifndefLine -1
		15	set prev ""
		16	foreach token [getTokens $fileName 1 0 -1 -1 {pp_ifndef pp_ifdef pp_if pp_include pp_define pp_undef pp_error pp_pragma pp_endif identifier}] {
		17	set type [lindex $token 3]
		18	set line [lindex $token 1]
		19
		20	if {$firstInstruction} {
		21	set firstInstruction 0
		22	if {$type != "pp_ifndef"} {
		23	report $fileName $line "The first preprocessor instruction of a header file should be the include guard of the form PROJECTNAME_FILENAME_H. (expected: $expectedGuard)"
		24	break
		25	} else {
		26	set ifndefLine $line
		27	}
		28	}
		29
		30	if {$prev == "pp_ifndef"} {
		31	if {$type == "identifier"} {
		32	set identifier [lindex $token 0]
		33	if {$identifier != $expectedGuard} {
		34	report $fileName $ifndefLine "The include guard should have the form PROJECTNAME_FILENAME_H. (Found $identifier, expected $expectedGuard)"
		35	}
		36	} else {
		37	report $fileName $ifndefLine "The first preprocessor instruction of a header file should be the include guard of the form PROJECTNAME_FILENAME_H. (expected: $expectedGuard)"
		38	}
		39	break
		40	}
		41
		42	set prev $type
		43	}
		44	}
		45	}

formatting/vera-root/scripts/rules/IPSIS_S03.tcl created 644 +25 0

			@@ -0,0 +1,25
		1	#!/usr/bin/tclsh
		2	# The macros in header files should begin with the name of the project to avoid
		3	# collisions
		4
		5	set projectName [string toupper [getParameter "project-name" "PROJECTNAMENOTFOUND"]]
		6
		7	foreach fileName [getSourceFileNames] {
		8	if {[regexp {\.h$} $fileName]} {
		9
		10	set prev ""
		11	foreach token [getTokens $fileName 1 0 -1 -1 {pp_define identifier}] {
		12	set type [lindex $token 3]
		13
		14	if {$prev == "pp_define" && $type == "identifier"} {
		15	set identifier [lindex $token 0]
		16	if {![regexp "^${projectName}.*$" $identifier]} {
		17	set line [lindex $token 1]
		18	report $fileName $line "The macros in header files should begin with the name of the project to avoid collisions. (project name: $projectName, macro found: $identifier)"
		19	}
		20	}
		21
		22	set prev $type
		23	}
		24	}
		25	}

formatting/vera-root/scripts/rules/IPSIS_S04_CLASS.tcl created 644 +124 0

			@@ -0,0 +1,124
		1	#!/usr/bin/tclsh
		2	# Naming conventions for classes and structs
		3
		4	set classRegex [getParameter "class-regex" {^[A-Z][A-Za-z1-9]*$}]
		5	set structRegex [getParameter "struct-regex" {^[A-Z][A-Za-z1-9]*$}]
		6
		7	proc createMachine {machineName initState} {
		8	set machine [dict create name $machineName state $initState identifier "" bracesCounter 0 bracketCounter 0 angleBracketCounter 0]
		9
		10	return $machine
		11	}
		12
		13	proc isClassMacro {value} {
		14	set classMacroRegexp [getParameter "classmacro-regex" {}]
		15	set classMacros {
		16	"Q_OBJECT"
		17	}
		18	set isClassMacroByRegexp 0
		19	if {[string length $classMacroRegexp] != 0} {
		20	set isClassMacroByRegexp [regexp $classMacroRegexp $value]
		21	}
		22	return [expr ([lsearch $classMacros $value] != -1) \|\| $isClassMacroByRegexp]
		23	}
		24
		25	proc isCppType {type value} {
		26	set cppTypes {
		27	"bool"
		28	"char"
		29	"int"
		30	"float"
		31	"double"
		32	"void"
		33	"wchart"
		34	"identifier"
		35	}
		36
		37	set valueIsClassMacro 0
		38	if {$type == "identifier"} {
		39	set valueIsClassMacro [isClassMacro $value]
		40	}
		41
		42	return [expr ([lsearch $cppTypes $type] != -1) && !$valueIsClassMacro]
		43	}
		44
		45	set tokenFilter {
		46	class
		47	struct
		48	leftbrace
		49	rightbrace
		50	semicolon
		51	colon
		52	identifier
		53	comma
		54	assign
		55	rightparen
		56	leftbracket
		57	}
		58
		59	foreach fileName [getSourceFileNames] {
		60
		61	set machines [list]
		62
		63	set lastIdentifier ""
		64	set lastIdentifier2 ""
		65	set prev1 ""
		66	set prev2 ""
		67	foreach token [getTokens $fileName 1 0 -1 -1 $tokenFilter] {
		68	set type [lindex $token 3]
		69	set line [lindex $token 1]
		70
		71	# Retrieve identifier value
		72	if {$type == "identifier"} {
		73	set lastIdentifier2 $lastIdentifier
		74	set lastIdentifier [lindex $token 0]
		75	}
		76
		77	# If the type is a class or a struct, start a class/struct state machine
		78	if {$type == "class"} {
		79	lappend machines [createMachine "class" "waitingForIdentifier"]
		80	}
		81	if {$type == "struct"} {
		82	lappend machines [createMachine "struct" "waitingForIdentifier"]
		83	}
		84
		85	set machinesToKeep [list]
		86	foreach m $machines {
		87	set keepMachine 1
		88	dict with m {
		89	# class/struct
		90	if {$name == "class" \|\| $name == "struct"} {
		91	# We retrieve the name of the class when we find a colon or
		92	# a leftbrace. We wait for these tokens to avoid the export
		93	# macros
		94	if {$state == "waitingForIdentifier" && ($type == "colon" \|\| $type == "leftbrace")} {
		95	set state "waitingForLeftBrace"
		96	set identifier $lastIdentifier
		97	}
		98
		99	if {$state == "waitingForLeftBrace" && $type == "leftbrace"} {
		100	if {$name == "class" && ![regexp $classRegex $identifier]} {
		101	report $fileName $line "The class names should match the following regex: $classRegex (found: $identifier)"
		102	}
		103	if {$name == "struct" && ![regexp $structRegex $identifier]} {
		104	report $fileName $line "The struct names should match the following regex: $structRegex (found: $identifier)"
		105	}
		106	}
		107
		108	if {[lsearch {semicolon leftbrace comma assign rightparen leftbracket} $type] != -1} {
		109	# End of the state machine
		110	set keepMachine 0
		111	}
		112	}
		113	}
		114
		115	if {$keepMachine} {
		116	lappend machinesToKeep $m
		117	}
		118	}
		119	set machines $machinesToKeep
		120
		121	set prev2 $prev1
		122	set prev1 $type
		123	}
		124	}

formatting/vera-root/scripts/rules/IPSIS_S04_ENUM.tcl created 644 +41 0

			@@ -0,0 +1,41
		1	#!/usr/bin/tclsh
		2	# Naming conventions for enums
		3
		4	set enumRegex [getParameter "enum-regex" {^[A-Z][A-Za-z1-9]*$}]
		5
		6	set tokenFilter {
		7	class
		8	struct
		9	enum
		10	typedef
		11	identifier
		12	leftbrace
		13	rightbrace
		14	semicolon
		15	}
		16
		17	foreach fileName [getSourceFileNames] {
		18
		19	set lastIdentifier ""
		20	set prev1 ""
		21	set prev2 ""
		22	foreach token [getTokens $fileName 1 0 -1 -1 $tokenFilter] {
		23	set type [lindex $token 3]
		24	set line [lindex $token 1]
		25
		26	# Retrieve identifier value
		27	if {$type == "identifier"} {
		28	set lastIdentifier [lindex $token 0]
		29	}
		30
		31	# Check enum
		32	if {$prev2 == "enum" && $prev1 == "identifier" && $type == "leftbrace"} {
		33	if {![regexp $enumRegex $lastIdentifier]} {
		34	report $fileName $line "The enum names should match the following regex: $enumRegex (found: $lastIdentifier)"
		35	}
		36	}
		37
		38	set prev2 $prev1
		39	set prev1 $type
		40	}
		41	}

formatting/vera-root/scripts/rules/IPSIS_S04_FILENAME.tcl created 644 +13 0

			@@ -0,0 +1,13
		1	#!/usr/bin/tclsh
		2	# Naming conventions for file names
		3
		4	set fileNameRegex [getParameter "filename-regex" {^[A-Z]\w*$}]
		5
		6	foreach fileName [getSourceFileNames] {
		7	# Check file name
		8	if {[regexp {(?:\\\|/)?([^\\/]+?)\.(?:h\|cpp)$} $fileName matchedExpr fileNameWithoutExt]} {
		9	if {![regexp $fileNameRegex $fileNameWithoutExt]} {
		10	report $fileName 1 "The file names should match the following regex: $fileNameRegex (found: $fileNameWithoutExt)"
		11	}
		12	}
		13	}

formatting/vera-root/scripts/rules/IPSIS_S04_METHOD.tcl created 644 +152 0

			@@ -0,0 +1,152
		1	#!/usr/bin/tclsh
		2	# Naming conventions for methods
		3
		4	set methodRegex [getParameter "method-regex" {^[a-z][A-Za-z1-9]*$}]
		5
		6	proc createMachine {machineName initState} {
		7	set machine [dict create name $machineName state $initState identifier "" bracesCounter 0 bracketCounter 0 angleBracketCounter 0]
		8	return $machine
		9	}
		10
		11	proc isClassMacro {value} {
		12	set classMacroRegexp [getParameter "classmacro-regex" {}]
		13	set classMacros {
		14	"Q_OBJECT"
		15	}
		16	set isClassMacroByRegexp 0
		17	if {[string length $classMacroRegexp] != 0} {
		18	set isClassMacroByRegexp [regexp $classMacroRegexp $value]
		19	}
		20	return [expr ([lsearch $classMacros $value] != -1) \|\| $isClassMacroByRegexp]
		21	}
		22
		23	proc isCppType {type value} {
		24	set cppTypes {
		25	"bool"
		26	"char"
		27	"int"
		28	"float"
		29	"double"
		30	"void"
		31	"wchart"
		32	"identifier"
		33	}
		34
		35	set valueIsClassMacro 0
		36	if {$type == "identifier"} {
		37	set valueIsClassMacro [isClassMacro $value]
		38	}
		39
		40	return [expr ([lsearch $cppTypes $type] != -1) && !$valueIsClassMacro]
		41	}
		42
		43	set tokenFilter {
		44	namespace
		45	class
		46	struct
		47	leftbrace
		48	rightbrace
		49	leftparen
		50	rightparen
		51	less
		52	greater
		53	semicolon
		54	identifier
		55	colon_colon
		56	assign
		57	pp_define
		58	bool
		59	char
		60	int
		61	float
		62	double
		63	void
		64	wchart
		65	}
		66
		67	foreach fileName [getSourceFileNames] {
		68
		69	set machines [list]
		70
		71	# Check the functions at the root of the file
		72	lappend machines [createMachine "method" "root"]
		73
		74	set lastIdentifier ""
		75	set lastIdentifier2 ""
		76	set prev1 ""
		77	set prev2 ""
		78	foreach token [getTokens $fileName 1 0 -1 -1 $tokenFilter] {
		79	set type [lindex $token 3]
		80	set line [lindex $token 1]
		81
		82	# Retrieve identifier value
		83	if {$type == "identifier"} {
		84	set lastIdentifier2 $lastIdentifier
		85	set lastIdentifier [lindex $token 0]
		86	}
		87
		88	# Start a method state machine when coming accross a namespace or a
		89	# class/struct
		90	if {$type == "namespace" \|\| $type == "class" \|\| $type == "struct"} {
		91	lappend machines [createMachine "method" "beforeLeftBrace"]
		92	}
		93
		94	set machinesToKeep [list]
		95	foreach m $machines {
		96	set keepMachine 1
		97	dict with m {
		98	# Method
		99	if {$name == "method"} {
		100	if {$state == "beforeLeftBrace"} {
		101	if {$type == "leftbrace"} {
		102	set state "root"
		103	} elseif {$type == "semicolon"} {
		104	set keepMachine 0
		105	}
		106	} elseif {$state == "root"} {
		107	if {[isCppType $prev2 $lastIdentifier2] && $prev1 == "identifier" && $type == "leftparen"} {
		108	if {![regexp $methodRegex $lastIdentifier]} {
		109	report $fileName $line "The method names should match the following regex: $methodRegex (found: $lastIdentifier)"
		110	}
		111	} elseif {$type == "leftbrace"} {
		112	set state "consumeBraces"
		113	incr bracesCounter
		114	} elseif {$type == "less"} {
		115	set state "consumeAngleBracket"
		116	incr angleBracketCounter
		117	} elseif {$type == "rightbrace"} {
		118	# End of the state machine
		119	set keepMachine 0
		120	}
		121	} elseif {$state == "consumeBraces"} {
		122	if {$type == "leftbrace"} {
		123	incr bracesCounter
		124	} elseif {$type == "rightbrace"} {
		125	incr bracesCounter -1
		126	if {$bracesCounter == 0} {
		127	set state "root"
		128	}
		129	}
		130	} elseif {$state == "consumeAngleBracket"} {
		131	if {$type == "less"} {
		132	incr angleBracketCounter
		133	} elseif {$type == "greater"} {
		134	incr angleBracketCounter -1
		135	if {$angleBracketCounter == 0} {
		136	set state "root"
		137	}
		138	}
		139	}
		140	}
		141	}
		142
		143	if {$keepMachine} {
		144	lappend machinesToKeep $m
		145	}
		146	}
		147	set machines $machinesToKeep
		148
		149	set prev2 $prev1
		150	set prev1 $type
		151	}
		152	}

formatting/vera-root/scripts/rules/IPSIS_S04_NAMESPACE.tcl created 644 +49 0

			@@ -0,0 +1,49
		1	#!/usr/bin/tclsh
		2	# Naming conventions for namespaces
		3
		4	set namespaceRegex [getParameter "namespace-regex" {^[a-z][a-z1-9]*$}]
		5
		6	proc createMachine {machineName initState} {
		7	set machine [dict create name $machineName state $initState identifier "" bracesCounter 0 bracketCounter 0 angleBracketCounter 0]
		8	return $machine
		9	}
		10
		11	set tokenFilter {
		12	using
		13	namespace
		14	identifier
		15	class
		16	struct
		17	enum
		18	typedef
		19	leftbrace
		20	rightbrace
		21	}
		22
		23	foreach fileName [getSourceFileNames] {
		24
		25	set machines [list]
		26
		27	set lastIdentifier ""
		28	set prev1 ""
		29	set prev2 ""
		30	foreach token [getTokens $fileName 1 0 -1 -1 $tokenFilter] {
		31	set type [lindex $token 3]
		32	set line [lindex $token 1]
		33
		34	# Retrieve identifier value
		35	if {$type == "identifier"} {
		36	set lastIdentifier [lindex $token 0]
		37	}
		38
		39	# Check namespace
		40	if {$prev2 == "namespace" && $prev1 == "identifier" && $type == "leftbrace"} {
		41	if {![regexp $namespaceRegex $lastIdentifier]} {
		42	report $fileName $line "The namespace names should match the following regex: $namespaceRegex (found: $lastIdentifier)"
		43	}
		44	}
		45
		46	set prev2 $prev1
		47	set prev1 $type
		48	}
		49	}

formatting/vera-root/scripts/rules/IPSIS_S04_TYPEDEF.tcl created 644 +87 0

			@@ -0,0 +1,87
		1	#!/usr/bin/tclsh
		2	# Naming conventions for typedefs
		3
		4	set typedefRegex [getParameter "type-regex" {^[A-Z][A-Za-z1-9]*$}]
		5
		6	proc createMachine {machineName initState} {
		7	set machine [dict create name $machineName state $initState identifier "" bracesCounter 0]
		8	return $machine
		9	}
		10
		11	set tokenFilter {
		12	typedef
		13	leftbrace
		14	rightbrace
		15	semicolon
		16	identifier
		17	}
		18
		19	foreach fileName [getSourceFileNames] {
		20
		21	set machines [list]
		22
		23	set lastIdentifier ""
		24	set lastIdentifier2 ""
		25	set prev1 ""
		26	set prev2 ""
		27	foreach token [getTokens $fileName 1 0 -1 -1 $tokenFilter] {
		28	set type [lindex $token 3]
		29	set line [lindex $token 1]
		30
		31	# Retrieve identifier value
		32	if {$type == "identifier"} {
		33	set lastIdentifier2 $lastIdentifier
		34	set lastIdentifier [lindex $token 0]
		35	}
		36
		37	# If the type is a typedef, start a typedef state machine
		38	if {$type == "typedef"} {
		39	lappend machines [createMachine "typedef" "waitingForIdentifier"]
		40	}
		41
		42	set machinesToKeep [list]
		43	foreach m $machines {
		44	set keepMachine 1
		45	dict with m {
		46	# typedef
		47	if {$name == "typedef"} {
		48	if {$state == "waitingForIdentifier"} {
		49	if {$type == "leftbrace"} {
		50	set state "consumeBraces"
		51	incr bracesCounter
		52	} elseif {$type == "semicolon"} {
		53	if {$prev1 == "identifier"} {
		54	# Check identifier
		55	if {![regexp $typedefRegex $lastIdentifier]} {
		56	report $fileName $line "The typedef names should match the following regex: $typedefRegex (found: $lastIdentifier)"
		57	}
		58	} else {
		59	# Typedef without identifier
		60	report $fileName $line "A typedef should have a name"
		61	}
		62	# End of the state machine
		63	set keepMachine 0
		64	}
		65	} elseif {$state == "consumeBraces"} {
		66	if {$type == "leftbrace"} {
		67	incr bracesCounter
		68	} elseif {$type == "rightbrace"} {
		69	incr bracesCounter -1
		70	if {$bracesCounter == 0} {
		71	set state "waitingForIdentifier"
		72	}
		73	}
		74	}
		75	}
		76	}
		77
		78	if {$keepMachine} {
		79	lappend machinesToKeep $m
		80	}
		81	}
		82	set machines $machinesToKeep
		83
		84	set prev2 $prev1
		85	set prev1 $type
		86	}
		87	}

formatting/vera-root/scripts/rules/IPSIS_S04_VARIABLE.tcl created 644 +351 0

			@@ -0,0 +1,351
		1	#!/usr/bin/tclsh
		2	# Naming conventions for variables
		3
		4	set localVariableRegex [getParameter "local-var-regex" {^[a-z][A-Za-z1-9]*$}]
		5	set classMemberVariableRegex [getParameter "class-member-var-regex" {^m_[A-Z][A-Za-z1-9]*$}]
		6	set structMemberVariableRegex [getParameter "struct-member-var-regex" {^[a-z][A-Za-z1-9]*$}]
		7	set staticMemberVariableRegex [getParameter "static-member-var-regex" {^s_[A-Z][A-Za-z1-9]*$}]
		8	set constVarRegex [getParameter "const-var-regex" {^[A-Z][A-Z1-9_]*$}]
		9
		10	proc createMachine {machineName initState} {
		11	set machine [dict create name $machineName state $initState previousState "" identifier "" bracesCounter 0 bracketCounter 0 angleBracketCounter 0]
		12
		13	# Specific keys for the "memberVariable" type
		14	if {$machineName == "memberVariable"} {
		15	dict set machine parenCounter 0
		16	dict set machine isStatic 0
		17	dict set machine isConst 0
		18	dict set machine isVar 1
		19	dict set machine isTypedef 0
		20	dict set machine isInClass 0
		21	dict set machine classOrStruct ""
		22	}
		23
		24	return $machine
		25	}
		26
		27	proc isClassMacro {value} {
		28	set classMacroRegexp [getParameter "classmacro-regex" {}]
		29	set classMacros {
		30	"Q_OBJECT"
		31	}
		32	set isClassMacroByRegexp 0
		33	if {[string length $classMacroRegexp] != 0} {
		34	set isClassMacroByRegexp [regexp $classMacroRegexp $value]
		35	}
		36	return [expr ([lsearch $classMacros $value] != -1) \|\| $isClassMacroByRegexp]
		37	}
		38
		39	proc isCppType {type value} {
		40	set cppTypes {
		41	"bool"
		42	"char"
		43	"int"
		44	"float"
		45	"double"
		46	"void"
		47	"wchart"
		48	"identifier"
		49	}
		50
		51	set valueIsClassMacro 0
		52	if {$type == "identifier"} {
		53	set valueIsClassMacro [isClassMacro $value]
		54	}
		55
		56	return [expr ([lsearch $cppTypes $type] != -1) && !$valueIsClassMacro]
		57	}
		58
		59	set tokenFilter {
		60	using
		61	namespace
		62	class
		63	struct
		64	enum
		65	typedef
		66	pp_define
		67	leftbrace
		68	rightbrace
		69	leftparen
		70	rightparen
		71	leftbracket
		72	rightbracket
		73	semicolon
		74	colon_colon
		75	colon
		76	comma
		77	dot
		78	arrow
		79	assign
		80	static
		81	const
		82	identifier
		83	bool
		84	char
		85	int
		86	float
		87	double
		88	void
		89	wchart
		90	return
		91	operator
		92	less
		93	greater
		94	}
		95
		96	foreach fileName [getSourceFileNames] {
		97	set machines [list]
		98
		99	# Check the functions at the root of the file
		100	lappend machines [createMachine "method" "root"]
		101
		102	# Check static const variables at the root of the file
		103	lappend machines [createMachine "memberVariable" "root"]
		104
		105	set lastIdentifier ""
		106	set lastIdentifier2 ""
		107	set prev1 ""
		108	set prev2 ""
		109	set insideFunctionParameters 0
		110	set insideFunction 0
		111	foreach token [getTokens $fileName 1 0 -1 -1 $tokenFilter] {
		112	set type [lindex $token 3]
		113	set line [lindex $token 1]
		114
		115	# Retrieve identifier value
		116	if {$type == "identifier"} {
		117	set lastIdentifier2 $lastIdentifier
		118	set lastIdentifier [lindex $token 0]
		119	}
		120
		121	if {$type == "namespace"} {
		122	# Look for the functions in the namespace to check the local variables
		123	lappend machines [createMachine "method" "beforeLeftBrace"]
		124	# Check the static const variables inside this namespace
		125	lappend machines [createMachine "memberVariable" "beforeLeftBrace"]
		126	} elseif {$type == "class" \|\| ($type == "struct" && !$insideFunctionParameters)} {
		127	# Look for the functions in the class/struct to check the local variables
		128	lappend machines [createMachine "method" "beforeLeftBrace"]
		129	# Check the static const variables inside this namespace
		130	set m [createMachine "memberVariable" "beforeLeftBrace"]
		131	dict set m isInClass 1
		132	dict set m classOrStruct $type
		133	lappend machines $m
		134	}
		135
		136	set machinesToKeep [list]
		137	foreach m $machines {
		138	set keepMachine 1
		139	dict with m {
		140	# Method
		141	if {$name == "method"} {
		142	if {$state == "beforeLeftBrace"} {
		143	if {$type == "leftbrace"} {
		144	set state "root"
		145	} elseif {$type == "semicolon"} {
		146	set keepMachine 0
		147	}
		148	} elseif {$state == "root"} {
		149	if {[isCppType $prev2 $lastIdentifier2] && $prev1 == "identifier" && $type == "leftparen"} {
		150	# Check the local variables inside this function
		151	set insideFunctionParameters 1
		152	set insideFunction 1
		153	lappend machinesToKeep [createMachine "localVariable" "beforeLeftBrace"]
		154
		155	} elseif {$type == "leftbrace"} {
		156	set state "consumeBraces"
		157	incr bracesCounter
		158	} elseif {$type == "rightbrace"} {
		159	# End of the state machine
		160	set keepMachine 0
		161	}
		162	} elseif {$state == "consumeBraces"} {
		163	if {$type == "leftbrace"} {
		164	incr bracesCounter
		165	} elseif {$type == "rightbrace"} {
		166	incr bracesCounter -1
		167	if {$bracesCounter == 0} {
		168	set state "root"
		169	}
		170	}
		171	}
		172	}
		173
		174	# Local variables
		175	if {$name == "localVariable"} {
		176	if {$state == "beforeLeftBrace"} {
		177	if {$type == "less"} {
		178	set previousState $state
		179	set state "consumeAngleBracket"
		180	incr angleBracketCounter
		181	} elseif {[isCppType $prev2 $lastIdentifier2] && $prev1 == "identifier" && ($type == "comma" \|\| $type == "assign" \|\| $type == "rightparen" \|\| $type == "leftbracket")} {
		182	# Check function parameters
		183	if {![regexp $localVariableRegex $lastIdentifier]} {
		184	report $fileName $line "The method parameter names should match the following regex: $localVariableRegex (found: $lastIdentifier)"
		185	}
		186	} elseif {$type == "leftbrace"} {
		187	set insideFunctionParameters 0
		188	set state "root"
		189	} elseif {$type == "semicolon"} {
		190	# End of the state machine
		191	set insideFunctionParameters 0
		192	set insideFunction 0
		193	set keepMachine 0
		194	}
		195	} elseif {$state == "root"} {
		196	if {$type == "leftbrace"} {
		197	incr bracesCounter
		198	} elseif {$type == "rightbrace"} {
		199	if {$bracesCounter > 0} {
		200	incr bracesCounter -1
		201	} else {
		202	# End of the state machine
		203	set insideFunctionParameters 0
		204	set insideFunction 0
		205	set keepMachine 0
		206	}
		207	}
		208
		209	if {[isCppType $prev2 $lastIdentifier2] && $prev1 == "identifier" && ($type == "assign" \|\| $type == "semicolon" \|\| $type == "leftparen" \|\| $type == "leftbracket")} {
		210	# Check local variable
		211	if {![regexp $localVariableRegex $lastIdentifier]} {
		212	report $fileName $line "The local variable names should match the following regex: $localVariableRegex (found: $lastIdentifier)"
		213	}
		214	}
		215	} elseif {$state == "consumeBracket"} {
		216	if {$type == "leftbracket"} {
		217	incr bracketCounter
		218	} elseif {$type == "rightbracket"} {
		219	incr bracketCounter -1
		220	if {$bracketCounter == 0} {
		221	set state $previousState
		222	}
		223	}
		224	} elseif {$state == "consumeAngleBracket"} {
		225	if {$type == "less"} {
		226	incr angleBracketCounter
		227	} elseif {$type == "greater"} {
		228	incr angleBracketCounter -1
		229	if {$angleBracketCounter == 0} {
		230	set state $previousState
		231	}
		232	}
		233	}
		234
		235	if {$state != "consumeBracket" && $type == "leftbracket"} {
		236	set previousState $state
		237	set state "consumeBracket"
		238	incr bracketCounter
		239	}
		240	}
		241
		242	# Member and const variables
		243	if {$name == "memberVariable"} {
		244	if {$state == "beforeLeftBrace"} {
		245	if {$type == "leftbrace"} {
		246	set state "root"
		247	} elseif {$type == "semicolon"} {
		248	set keepMachine 0
		249	}
		250	} elseif {$state == "root"} {
		251	# is/isn't var
		252	if {$type == "using" \|\| $type == "class" \|\| $type == "struct"} {
		253	set isVar 0
		254	} elseif {$type == "typedef"} {
		255	set isTypedef 1
		256	}
		257
		258	# static/const
		259	if {$type == "static"} {
		260	set isStatic 1
		261	} elseif {$type == "const"} {
		262	set isConst 1
		263	}
		264
		265	if {$isVar && !$isTypedef && $prev1 == "pp_define" && $type == "identifier"} {
		266	# Check defines
		267	if {![regexp $constVarRegex $lastIdentifier]} {
		268	report $fileName $line "The constant names should match the following regex: $constVarRegex (found: $lastIdentifier)"
		269	}
		270	} elseif {$isVar && !$isTypedef && $prev1 == "identifier" && ($type == "assign" \|\| $type == "semicolon" \|\| $type == "leftbracket")} {
		271	# Check member variables
		272	# Appart from the const, we don't check the member variables outside
		273	# of their classes to avoid false positive
		274	if {((!$isInClass && $isConst) \|\| ($isInClass && $isStatic && $isConst)) && ![regexp $constVarRegex $lastIdentifier]} {
		275	report $fileName $line "The constant names should match the following regex: $constVarRegex (found: $lastIdentifier)"
		276	} elseif {$isInClass && $isStatic && !$isConst && ![regexp $staticMemberVariableRegex $lastIdentifier]} {
		277	report $fileName $line "The static member variable names should match the following regex: $staticMemberVariableRegex (found: $lastIdentifier)"
		278	} elseif {$isInClass && !$isStatic} {
		279	if {$classOrStruct == "class" && ![regexp $classMemberVariableRegex $lastIdentifier]} {
		280	report $fileName $line "The class member variable names should match the following regex: $classMemberVariableRegex (found: $lastIdentifier)"
		281	} elseif {$classOrStruct == "struct" && ![regexp $structMemberVariableRegex $lastIdentifier] && ![regexp $classMemberVariableRegex $lastIdentifier]} {
		282	report $fileName $line "The struct member variable names should match the following regex: $structMemberVariableRegex or the class member regex: $classMemberVariableRegex (found: $lastIdentifier)"
		283	}
		284	}
		285	} elseif {$type == "leftbrace"} {
		286	set state "consumeBraces"
		287	incr bracesCounter
		288	} elseif {$type == "leftparen"} {
		289	set state "consumeParen"
		290	incr parenCounter
		291	} elseif {$type == "rightbrace"} {
		292	# End of the state machine
		293	set keepMachine 0
		294	}
		295
		296	if {$type == "leftbracket"} {
		297	incr bracketCounter
		298	set state "consumeBracket"
		299	}
		300
		301	# Reinit static, const and isVar
		302	if {$type == "assign" \|\| $type == "semicolon" \|\| $type == "leftbrace"} {
		303	set isStatic 0
		304	set isConst 0
		305	set isVar 1
		306	}
		307
		308	if {$type == "semicolon"} {
		309	set isTypedef 0
		310	}
		311	} elseif {$state == "consumeBraces"} {
		312	if {$type == "leftbrace"} {
		313	incr bracesCounter
		314	} elseif {$type == "rightbrace"} {
		315	incr bracesCounter -1
		316	if {$bracesCounter == 0} {
		317	set state "root"
		318	}
		319	}
		320	} elseif {$state == "consumeParen"} {
		321	if {$type == "leftparen"} {
		322	incr parenCounter
		323	} elseif {$type == "rightparen"} {
		324	incr parenCounter -1
		325	if {$parenCounter == 0} {
		326	set state "root"
		327	}
		328	}
		329	} elseif {$state == "consumeBracket"} {
		330	if {$type == "leftbracket"} {
		331	incr bracketCounter
		332	} elseif {$type == "rightbracket"} {
		333	incr bracketCounter -1
		334	if {$bracketCounter == 0} {
		335	set state "root"
		336	}
		337	}
		338	}
		339	}
		340	}
		341
		342	if {$keepMachine} {
		343	lappend machinesToKeep $m
		344	}
		345	}
		346	set machines $machinesToKeep
		347
		348	set prev2 $prev1
		349	set prev1 $type
		350	}
		351	}

formatting/vera-root/scripts/rules/IPSIS_S05.tcl created 644 +329 0

			@@ -0,0 +1,329
		1	#!/usr/bin/tclsh
		2	# Declaration order inside classes
		3
		4	proc createMachine {visibility initState} {
		5	set machine [dict create visibility $visibility state $initState waitingFor "typedef" previousState "" bracesCounter 0 isStatic 0]
		6	return $machine
		7	}
		8
		9	proc createVisibilityMachine {} {
		10	set machine [dict create state "beforeLeftBrace" visibilityState "waitingForPublic" bracesCounter 0 visibility ""]
		11	return $machine
		12	}
		13
		14	set tokenFilter {
		15	public
		16	protected
		17	private
		18	colon
		19	typedef
		20	class
		21	struct
		22	enum
		23	static
		24	const
		25	identifier
		26	operator
		27	assign
		28	semicolon
		29	leftbrace
		30	rightbrace
		31	leftparen
		32	rightparen
		33	}
		34
		35	set globalOrder "The global order is public members then public slots, protected members then protected slots and private members then private slots."
		36
		37	foreach fileName [getSourceFileNames] {
		38	set machines [list]
		39	set visibilityMachines [list]
		40
		41	set visibilityState "waitingForPublic"
		42
		43	set prev1 ""
		44	set prev2 ""
		45	set lastIdentifier ""
		46	foreach token [getTokens $fileName 1 0 -1 -1 $tokenFilter] {
		47	set type [lindex $token 3]
		48	set line [lindex $token 1]
		49
		50	if {$type == "identifier"} {
		51	set lastIdentifier [lindex $token 0]
		52	}
		53
		54	if {$type == "class" \|\| $type == "struct"} {
		55	lappend visibilityMachines [createVisibilityMachine]
		56	}
		57
		58	if {$type == "colon" && ($prev1 == "public" \|\| $prev1 == "protected" \|\| $prev1 == "private")} {
		59	lappend machines [createMachine $prev1 "beforeVisibility"]
		60	}
		61
		62	# Machines for the visibility order
		63	set visibilityMachinesToKeep [list]
		64	foreach m $visibilityMachines {
		65	set keepMachine 1
		66	dict with m {
		67	if {$state == "beforeLeftBrace"} {
		68	if {$type == "semicolon"} {
		69	set keepMachine 0
		70	} elseif {$type == "leftbrace"} {
		71	set state "root"
		72	}
		73	} elseif {$state == "root"} {
		74	if {$type == "public" \|\| $type == "protected" \|\| $type == "private"} {
		75	set visibility $type
		76	set state "waitingForColon"
		77	} elseif {$type == "leftbrace"} {
		78	incr bracesCounter
		79	set state "consumeBraces"
		80	} elseif {$type == "rightbrace"} {
		81	set keepMachine 0
		82	}
		83	} elseif {$state == "waitingForColon"} {
		84	if {$type == "colon"} {
		85	if {$visibility == "public" && $prev1 != "identifier"} {
		86	if {$visibilityState == "waitingForPublicSlots"
		87	\|\| $visibilityState == "waitingForProtected"
		88	\|\| $visibilityState == "waitingForProtectedSlots"
		89	\|\| $visibilityState == "waitingForPrivate"
		90	\|\| $visibilityState == "waitingForPrivateSlots"
		91	\|\| $visibilityState == "done"} {
		92	report $fileName $line "There should be at most one public visibility and it should be at the start of the class. $globalOrder"
		93	} else {
		94	set visibilityState "waitingForPublicSlots"
		95	}
		96	} elseif {$visibility == "public" && $prev1 == "identifier" && $lastIdentifier == "slots"} {
		97	if {$visibilityState == "waitingForProtected"
		98	\|\| $visibilityState == "waitingForProtectedSlots"
		99	\|\| $visibilityState == "waitingForPrivate"
		100	\|\| $visibilityState == "waitingForPrivateSlots"
		101	\|\| $visibilityState == "done"} {
		102	report $fileName $line "There should be at most one public slots visibility and it should be between public and protected. $globalOrder"
		103	} else {
		104	set visibilityState "waitingForProtected"
		105	}
		106	} elseif {$visibility == "protected" && $prev1 != "identifier"} {
		107	if {$visibilityState == "waitingForProtectedSlots"
		108	\|\| $visibilityState == "waitingForPrivate"
		109	\|\| $visibilityState == "waitingForPrivateSlots"
		110	\|\| $visibilityState == "done"} {
		111	report $fileName $line "There should be at most one protected visibility and it should be between public slots and protected slots. $globalOrder"
		112	} else {
		113	set visibilityState "waitingForProtectedSlots"
		114	}
		115	} elseif {$visibility == "protected" && $prev1 == "identifier" && $lastIdentifier == "slots"} {
		116	if {$visibilityState == "waitingForPrivate"
		117	\|\| $visibilityState == "waitingForPrivateSlots"
		118	\|\| $visibilityState == "done"} {
		119	report $fileName $line "There should be at most one protected slots visibility and it should be between protected and private. $globalOrder"
		120	} else {
		121	set visibilityState "waitingForPrivate"
		122	}
		123	} elseif {$visibility == "private" && $prev1 != "identifier"} {
		124	if {$visibilityState == "waitingForPrivateSlots"
		125	\|\| $visibilityState == "done"} {
		126	report $fileName $line "There should be at most one private visibility and it should be between protected slots and private slots. $globalOrder"
		127	} else {
		128	set visibilityState "waitingForPrivateSlots"
		129	}
		130	} elseif {$visibility == "private" && $prev1 == "identifier" && $lastIdentifier == "slots"} {
		131	if {$visibilityState == "done"} {
		132	report $fileName $line "There should be at most one private visibility and it should be the last of the class. $globalOrder"
		133	} else {
		134	set visibilityState "done"
		135	}
		136	}
		137
		138	set state "root"
		139	}
		140	} elseif {$state == "consumeBraces"} {
		141	if {$type == "leftbrace"} {
		142	incr bracesCounter
		143	} elseif {$type == "rightbrace"} {
		144	incr bracesCounter -1
		145	if {$bracesCounter == 0} {
		146	set state "root"
		147	}
		148	}
		149	}
		150	}
		151
		152	if {$keepMachine} {
		153	lappend visibilityMachinesToKeep $m
		154	}
		155	}
		156	set visibilityMachines $visibilityMachinesToKeep
		157
		158	# Machines for the declaration order inside a visibility
		159	set machinesToKeep [list]
		160	foreach m $machines {
		161	set keepMachine 1
		162	dict with m {
		163	if {$state == "beforeVisibility" && $type == $visibility} {
		164	set state "root"
		165	} elseif {$state == "root"} {
		166	if {$type == "public" \|\| $type == "protected" \|\| $type == "private" \|\| $type == "rightbrace"} {
		167	# End of the state machine when we reach the next
		168	# visibility block
		169	set keepMachine 0
		170	} else {
		171	if {$type == "static"} {
		172	set isStatic 1
		173	}
		174
		175	if {$waitingFor == "typedef"} {
		176	if {$type == "typedef"} {
		177	set state "consumeUntilNextSemiColon"
		178	} else {
		179	set waitingFor "enum"
		180	}
		181	}
		182
		183	if {$waitingFor == "enum"} {
		184	if {$type == "typedef"} {
		185	set state "consumeUntilNextSemiColon"
		186	report $fileName $line "The typedefs should be before the enums"
		187	} elseif {$type == "enum"} {
		188	set state "consumeUntilNextSemiColon"
		189	} else {
		190	set waitingFor "class/struct"
		191	}
		192	}
		193
		194	if {$waitingFor == "class/struct"} {
		195	if {$type == "typedef" \|\| $type == "enum"} {
		196	set state "consumeUntilNextSemiColon"
		197	report $fileName $line "The typedefs and enums should be before the classes/structs"
		198	} elseif {$type == "class" \|\| $type == "struct"} {
		199	set state "consumeUntilNextSemiColon"
		200	} else {
		201	set waitingFor "staticFunc"
		202	}
		203	}
		204
		205	if {$waitingFor == "staticFunc"} {
		206	if {$type == "typedef" \|\| $type == "enum" \|\| $type == "class" \|\| $type == "struct"} {
		207	set state "consumeUntilNextSemiColon"
		208	report $fileName $line "The typedefs, enums, classes and structs should be before the static functions"
		209	} elseif {$prev1 == "identifier"} {
		210	if {$type == "leftparen"} {
		211	if {$isStatic} {
		212	set state "consumeFunction"
		213	} else {
		214	set waitingFor "method"
		215	}
		216	} elseif {$type == "assign" \|\| $type == "semicolon"} {
		217	set waitingFor "staticVar"
		218	}
		219	}
		220	}
		221
		222	if {$waitingFor == "staticVar"} {
		223	if {$type == "typedef" \|\| $type == "enum" \|\| $type == "class" \|\| $type == "struct"} {
		224	set state "consumeUntilNextSemiColon"
		225	report $fileName $line "The typedefs, enums, classes and structs should be before the static variables"
		226	} elseif {$prev1 == "identifier"} {
		227	if {$type == "leftparen"} {
		228	if {$isStatic} {
		229	set state "consumeFunction"
		230	report $fileName $line "The static functions should be before the static variables"
		231	} else {
		232	set waitingFor "method"
		233	}
		234	} elseif {$type == "assign" \|\| $type == "semicolon"} {
		235	if {!$isStatic} {
		236	set waitingFor "method"
		237	}
		238	if {$type != "semicolon"} {
		239	set state "consumeUntilNextSemiColon"
		240	} else {
		241	set isStatic 0
		242	}
		243	}
		244	}
		245	}
		246
		247	if {$waitingFor == "method"} {
		248	if {$type == "typedef" \|\| $type == "enum" \|\| $type == "class" \|\| $type == "struct"} {
		249	set state "consumeUntilNextSemiColon"
		250	report $fileName $line "The typedefs, enums, classes and structs should be before the methods"
		251	} elseif {$prev2 == "identifier" && $prev1 == "operator" && $type == "assign"} {
		252	# override of operator=()
		253	set state "consumeFunction"
		254	} elseif {$prev1 == "identifier"} {
		255	if {$type == "leftparen"} {
		256	if {$isStatic} {
		257	report $fileName $line "The static functions should be before the methods"
		258	}
		259	set state "consumeFunction"
		260	} elseif {$type == "assign" \|\| $type == "semicolon"} {
		261	if {$isStatic} {
		262	report $fileName $line "The static variables should be before the methods"
		263	} else {
		264	set waitingFor "var"
		265	}
		266	}
		267	}
		268	}
		269
		270	if {$waitingFor == "var"} {
		271	if {$type == "typedef" \|\| $type == "enum" \|\| $type == "class" \|\| $type == "struct"} {
		272	set state "consumeUntilNextSemiColon"
		273	report $fileName $line "The typedefs, enums, classes and structs should be before the variables"
		274	} elseif {$prev1 == "identifier"} {
		275	if {$type == "leftparen"} {
		276	if {$isStatic} {
		277	report $fileName $line "The static functions should be before the variables"
		278	} else {
		279	report $fileName $line "The methods should be before the variables"
		280	}
		281	set state "consumeFunction"
		282	} elseif {$type == "assign" \|\| $type == "semicolon"} {
		283	if {$isStatic} {
		284	report $fileName $line "The static variables should be before the variables"
		285	}
		286	}
		287	}
		288	}
		289	}
		290	} elseif {$state == "consumeUntilNextSemiColon"} {
		291	set isStatic 0
		292	if {$type == "semicolon"} {
		293	set state "root"
		294	} elseif {$type == "leftbrace"} {
		295	incr bracesCounter
		296	set previousState $state
		297	set state "consumeBraces"
		298	}
		299	} elseif {$state == "consumeFunction"} {
		300	set isStatic 0
		301	if {$type == "semicolon"} {
		302	set state "root"
		303	} elseif {$type == "leftbrace"} {
		304	incr bracesCounter
		305	set previousState "root"
		306	set state "consumeBraces"
		307	}
		308	} elseif {$state == "consumeBraces"} {
		309	if {$type == "leftbrace"} {
		310	incr bracesCounter
		311	} elseif {$type == "rightbrace"} {
		312	incr bracesCounter -1
		313	if {$bracesCounter == 0} {
		314	set state $previousState
		315	}
		316	}
		317	}
		318	}
		319
		320	if {$keepMachine} {
		321	lappend machinesToKeep $m
		322	}
		323	}
		324	set machines $machinesToKeep
		325
		326	set prev2 $prev1
		327	set prev1 $type
		328	}
		329	} No newline at end of file

formatting/vera-root/scripts/rules/IPSIS_S06.tcl created 644 +166 0

			@@ -0,0 +1,166
		1	#!/usr/bin/tclsh
		2	# Forbid public member variables
		3
		4	set forbidPublicMemberVarInStruct [getParameter "also-forbid-public-member-var-in-struct" 0]
		5
		6	proc createMachine {type initState} {
		7	set machine [dict create classOrStruct $type state $initState previousState "" bracesCounter 0 parenCounter 0 bracketCounter 0 isStatic 0 isTypedef 0 isRootClass 0]
		8	return $machine
		9	}
		10
		11	set tokenFilter {
		12	public
		13	protected
		14	private
		15	typedef
		16	enum
		17	class
		18	struct
		19	static
		20	identifier
		21	assign
		22	semicolon
		23	leftbrace
		24	rightbrace
		25	leftparen
		26	rightparen
		27	leftbracket
		28	rightbracket
		29	operator
		30	}
		31
		32	foreach fileName [getSourceFileNames] {
		33	if {[regexp {\.h$} $fileName]} {
		34	set machines [list]
		35
		36	set rootClass 1
		37	set lastIdentifier ""
		38	set prev1 ""
		39	foreach token [getTokens $fileName 1 0 -1 -1 $tokenFilter] {
		40	set type [lindex $token 3]
		41	set line [lindex $token 1]
		42
		43	if {$type == "identifier"} {
		44	set lastIdentifier [lindex $token 0]
		45	}
		46
		47	if {$rootClass && ($type == "class" \|\| $type == "struct")} {
		48	set m [createMachine $type "beforeLeftBrace"]
		49	dict set m isRootClass 1
		50	lappend machines $m
		51	set rootClass 0
		52	}
		53
		54	set machinesToKeep [list]
		55	foreach m $machines {
		56	set keepMachine 1
		57	dict with m {
		58	if {$state == "beforeLeftBrace"} {
		59	if {$type == "leftbrace"} {
		60	if {$classOrStruct == "class"} {
		61	set state "root"
		62	} elseif {$classOrStruct == "struct"} {
		63	set state "public"
		64	}
		65	} elseif {$type == "semicolon"} {
		66	set keepMachine 0
		67	set rootClass $isRootClass
		68	}
		69	} elseif {$state == "root"} {
		70	if {$type == "public"} {
		71	set state "public"
		72	} elseif {$type == "leftbrace"} {
		73	incr bracesCounter
		74	set previousState $state
		75	set state "consumeBraces"
		76	} elseif {$type == "rightbrace"} {
		77	set keepMachine 0
		78	set rootClass $isRootClass
		79	}
		80	} elseif {$state == "public"} {
		81	if {$type == "class" \|\| $type == "struct"} {
		82	lappend machinesToKeep [createMachine $type "beforeLeftBrace"]
		83	}
		84
		85	if {$type == "static"} {
		86	set isStatic 1
		87	}
		88	if {$type == "typedef"} {
		89	set isTypedef 1
		90	}
		91
		92	if {$prev1 == "identifier" && ($type == "assign" \|\| $type == "semicolon" \|\| $type == "leftbracket")} {
		93	if {!$isStatic && !$isTypedef} {
		94	if {($classOrStruct == "class") \|\| ($classOrStruct == "struct" && $forbidPublicMemberVarInStruct)} {
		95	report $fileName $line "Public member variables are forbidden in $classOrStruct (found: $lastIdentifier)"
		96	}
		97	}
		98	} elseif {$type == "protected" \|\| $type == "private"} {
		99	set isStatic 0
		100	set isTypedef 0
		101	set state "root"
		102	} elseif {$type == "leftbrace"} {
		103	incr bracesCounter
		104	set previousState $state
		105	set state "consumeBraces"
		106	} elseif {$type == "leftparen"} {
		107	incr parenCounter
		108	set previousState $state
		109	set state "consumeParen"
		110	} elseif {$type == "rightbrace"} {
		111	set keepMachine 0
		112	set rootClass $isRootClass
		113	}
		114
		115	if {$type == "leftbracket"} {
		116	incr bracketCounter
		117	set previousState $state
		118	set state "consumeBracket"
		119	}
		120
		121	if {$type == "semicolon" \|\| $type == "leftbrace"} {
		122	set isStatic 0
		123	}
		124	if {$type == "semicolon"} {
		125	set isTypedef 0
		126	}
		127	} elseif {$state == "consumeBraces"} {
		128	if {$type == "leftbrace"} {
		129	incr bracesCounter
		130	} elseif {$type == "rightbrace"} {
		131	incr bracesCounter -1
		132	if {$bracesCounter == 0} {
		133	set state $previousState
		134	}
		135	}
		136	} elseif {$state == "consumeParen"} {
		137	if {$type == "leftparen"} {
		138	incr parenCounter
		139	} elseif {$type == "rightparen"} {
		140	incr parenCounter -1
		141	if {$parenCounter == 0} {
		142	set state $previousState
		143	}
		144	}
		145	} elseif {$state == "consumeBracket"} {
		146	if {$type == "leftbracket"} {
		147	incr bracketCounter
		148	} elseif {$type == "rightbracket"} {
		149	incr bracketCounter -1
		150	if {$bracketCounter == 0} {
		151	set state $previousState
		152	}
		153	}
		154	}
		155	}
		156
		157	if {$keepMachine} {
		158	lappend machinesToKeep $m
		159	}
		160	}
		161	set machines $machinesToKeep
		162
		163	set prev1 $type
		164	}
		165	}
		166	}

formatting/vera-root/scripts/rules/IPSIS_S09.tcl created 644 +60 0

			@@ -0,0 +1,60
		1	#!/usr/bin/tclsh
		2	# Prefer C++ includes of the C std headers (cstdio instead of stdio.h for instance)
		3
		4	set cStdHeaders {
		5	assert.h
		6	complex.h
		7	ctype.h
		8	errno.h
		9	fenv.h
		10	float.h
		11	inttypes.h
		12	iso646.h
		13	limits.h
		14	locale.h
		15	math.h
		16	setjmp.h
		17	signal.h
		18	stdalign.h
		19	stdarg.h
		20	stdbool.h
		21	stddef.h
		22	stdint.h
		23	stdio.h
		24	stdlib.h
		25	string.h
		26	tgmath.h
		27	time.h
		28	uchar.h
		29	wchar.h
		30	wctype.h
		31	}
		32
		33	set cStdHeadersWithDifferentCppEquivalent [dict create \
		34	stdatomic.h atomic \
		35	threads.h thread \
		36	]
		37
		38	set cStdHeadersWithNoCppEquivalent {
		39	stdnoreturn.h
		40	}
		41
		42	foreach fileName [getSourceFileNames] {
		43	foreach token [getTokens $fileName 1 0 -1 -1 {pp_hheader}] {
		44	set line [lindex $token 1]
		45	set value [lindex $token 0]
		46
		47	if {[regexp {^[^<]?<(.)>[^>]*?$} $value matched headerName]} {
		48	if {[lsearch $cStdHeaders $headerName] != -1} {
		49	set headerWithoutExt [string range $headerName 0 [expr [string length $headerName] - 3]]
		50	set cppHeader "c$headerWithoutExt"
		51	report $fileName $line "$headerName is a C include, use the equivalent C++ include <$cppHeader>"
		52	} elseif {[dict exists $cStdHeadersWithDifferentCppEquivalent $headerName]} {
		53	set cppHeader [dict get $cStdHeadersWithDifferentCppEquivalent $headerName]
		54	report $fileName $line "$headerName is a C include, use the equivalent C++ include <$cppHeader>"
		55	} elseif {[lsearch $cStdHeadersWithNoCppEquivalent $headerName] != -1} {
		56	report $fileName $line "$headerName is a C include without C++ equivalent. Use the C++ constructions instead of relying on C headers."
		57	}
		58	}
		59	}
		60	}

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages