1771 lines
47 KiB
Tcl
Executable File
1771 lines
47 KiB
Tcl
Executable File
#!/usr/bin/tclsh
|
||
|
||
#
|
||
# \brief C++-coding-style checking tool
|
||
# \author Norman Feske
|
||
# \date 2007-08-17
|
||
#
|
||
|
||
# check command line arguments (read input filename and remove argument
|
||
regexp -- {-tokens +([^\s]+)} $argv dummy input_token_file
|
||
regsub -- {-tokens +([^\s]+)} $argv "" argv]
|
||
|
||
set config_fix [regexp -- {-fix\M} $argv dummy]
|
||
regsub -- {-fix\M} $argv "" argv]
|
||
|
||
set config_write [regexp -- {-write\M} $argv dummy]
|
||
regsub -- {-write\M} $argv "" argv]
|
||
|
||
|
||
#################################################
|
||
## Read input and fill internal representation ##
|
||
#################################################
|
||
|
||
##
|
||
# Find location of 'parse_cxx'
|
||
#
|
||
# We expect to find 'parse_cxx' in the same directory
|
||
# as we are located. The question is: Where are we?
|
||
##
|
||
proc parse_cxx_file { } {
|
||
global argv0
|
||
|
||
set path $argv0
|
||
|
||
if {[file type $path] == "link"} {
|
||
set path [file readlink $path] }
|
||
|
||
set parse_cxx_file "[file dirname $path]/parse_cxx"
|
||
|
||
if {![file exists $parse_cxx_file]} {
|
||
puts stderr "Error: Could not find 'parse_cxx' in '$path'."
|
||
exit -1
|
||
}
|
||
return $parse_cxx_file
|
||
}
|
||
|
||
|
||
set input_source [lindex $argv end]
|
||
|
||
if {![file exists $input_source]} {
|
||
puts stderr ""
|
||
puts stderr "Check adherence to Genode's C++ coding style"
|
||
puts stderr "\n usage: beautify \[-tokens <token_file>\] \[-fix\] \[-write\] \[<source_file>\]"
|
||
puts stderr ""
|
||
puts stderr "For normal use, <source_file> is the name of the file to analyse."
|
||
puts stderr "If the '-tokens' argument is specified, the input is taken"
|
||
puts stderr "directly from a file containing a token list. This is useful"
|
||
puts stderr "for debugging."
|
||
puts stderr "By specifying the '-fix' argument, a proposed version for"
|
||
puts stderr "the source file will be written to stdout. This version may"
|
||
puts stderr "contain warning directives for manual revision."
|
||
puts stderr "If the option '-write' is specific in addition to '-fix', the"
|
||
puts stderr "fixed version of the file gets written back to the source code."
|
||
puts stderr ""
|
||
exit -1;
|
||
}
|
||
|
||
set tokens {}
|
||
if {[info exists input_token_file]} {
|
||
set tokens [exec cat $input_token_file]
|
||
} else {
|
||
if {[catch {
|
||
set tokens [exec [parse_cxx_file] -format tokens $input_source]
|
||
}]} {
|
||
puts stderr "Error: parsing the C++ file '$input_source' failed"
|
||
puts stderr "Parser output follows:\n$tokens"
|
||
}
|
||
}
|
||
|
||
foreach token $tokens {
|
||
set name [lindex $token 0]
|
||
set line [lindex $token 1]
|
||
set text [lindex $token 2]
|
||
set tok_text($name) "$text"
|
||
set tok_line($name) $line
|
||
}
|
||
|
||
if {![info exists tok_text(content0)]} {
|
||
puts stderr "Error: input contains no root token 'content0'."
|
||
exit -1
|
||
}
|
||
|
||
|
||
##
|
||
# Return current (partially corrected) code and abort
|
||
##
|
||
proc abort {{message ""}} {
|
||
global config_write
|
||
global config_fix
|
||
global input_source
|
||
|
||
if {$message != ""} { puts stderr "Aborting code check: $message" }
|
||
if {$config_fix} {
|
||
|
||
# use stdout by default
|
||
set fd stdout
|
||
|
||
# if called with '-write', write the changes back to source file
|
||
if {$config_write} {
|
||
set fd [open $input_source "WRONLY CREAT TRUNC"] }
|
||
|
||
dump_source content0 $fd
|
||
|
||
close $fd
|
||
}
|
||
exit
|
||
}
|
||
|
||
|
||
proc msg { message } { puts stderr $message }
|
||
|
||
|
||
##
|
||
# Print warning message
|
||
##
|
||
proc warn {message {token ""} {prefix Warning}} {
|
||
global tok_line
|
||
set line ""
|
||
catch { set line " at line $tok_line($token)" }
|
||
puts stderr "$prefix$line: $message"
|
||
}
|
||
|
||
|
||
##
|
||
# Print error message
|
||
##
|
||
proc error {message {token ""}} { warn $message $token Error }
|
||
|
||
|
||
##########################
|
||
## Source-code back end ##
|
||
##########################
|
||
|
||
##
|
||
# Output syntax tree as XML
|
||
##
|
||
proc dump_source {token fd} {
|
||
global tok_text
|
||
|
||
set output $tok_text($token)
|
||
|
||
while {$output != ""} {
|
||
|
||
# consume plain text
|
||
if {[regexp {^[^<EFBFBD>]+} $output plain]} {
|
||
regsub -all {<EFBFBD>} $plain "\\\&" plain
|
||
puts -nonewline $fd $plain
|
||
regsub {^[^<EFBFBD>]+} $output "" output
|
||
}
|
||
|
||
# consume token
|
||
if {[regexp {<EFBFBD>(.+?)<EFBFBD>} $output dummy subtoken]} {
|
||
dump_source $subtoken $fd
|
||
regsub {<EFBFBD>(.+?)<EFBFBD>} $output "" output
|
||
}
|
||
}
|
||
|
||
# append newline at end of output
|
||
if {$token == "content0"} { puts $fd "" }
|
||
}
|
||
|
||
|
||
###########################
|
||
## Syntax-tree utilities ##
|
||
###########################
|
||
|
||
##
|
||
# Select list of tokens of specified type from subtree
|
||
##
|
||
proc select_by_type {tok_type {token content0} {max_depth 999}} {
|
||
global tok_text
|
||
|
||
if {$max_depth == "0"} { return }
|
||
|
||
incr max_depth -1
|
||
|
||
set txt $tok_text($token)
|
||
|
||
set result [list]
|
||
|
||
while {$txt != ""} {
|
||
|
||
# consume plain text
|
||
if {[regexp {^[^<EFBFBD>]+} $txt plain]} {
|
||
regsub {^[^<EFBFBD>]+} $txt "" txt }
|
||
|
||
# consume token
|
||
if {[regexp {<EFBFBD>(.+?)<EFBFBD>} $txt dummy subtoken]} {
|
||
|
||
if {[regexp "^$tok_type\\d+\$" $subtoken dummy]} {
|
||
lappend result $subtoken }
|
||
|
||
# traverse into subtoken
|
||
set result [concat $result [select_by_type $tok_type $subtoken $max_depth]]
|
||
|
||
# eat token
|
||
regsub {<EFBFBD>(.+?)<EFBFBD>} $txt "" txt
|
||
}
|
||
}
|
||
return $result
|
||
}
|
||
|
||
|
||
##
|
||
# Return list of all tokens
|
||
##
|
||
proc select_all { } { return "content0 [select_by_type {.*}]" }
|
||
|
||
|
||
##
|
||
# Return list of tokes contained in the string
|
||
##
|
||
proc list_of_tokens { string } {
|
||
set result { }
|
||
while {[regexp {<EFBFBD>(\w+\d+)<EFBFBD>} $string dummy tok]} {
|
||
lappend result $tok
|
||
regsub {<EFBFBD>(\w+\d+)<EFBFBD>} $string "" string
|
||
}
|
||
return $result
|
||
}
|
||
|
||
|
||
##
|
||
# Expand all tokens of string
|
||
##
|
||
proc expand { txt } {
|
||
global tok_text
|
||
|
||
set pattern {<EFBFBD>(.+?)<EFBFBD>}
|
||
while {[regexp $pattern $txt dummy token]} {
|
||
|
||
# avoid backslash to be used as re back references
|
||
regsub -all {\\} $tok_text($token) {\\\\} expanded_txt
|
||
regsub -- $pattern $txt $expanded_txt txt
|
||
}
|
||
return $txt
|
||
}
|
||
|
||
|
||
##
|
||
# Expand subtree of token
|
||
##
|
||
proc expand_token { token } {
|
||
global tok_text
|
||
return [expand $tok_text($token)]
|
||
}
|
||
|
||
|
||
##
|
||
# Return number of line breaks contained in the speficied sub tree
|
||
##
|
||
proc count_line_breaks { token } {
|
||
set txt [expand_token $token]
|
||
set num_lines 0
|
||
while {[regsub "\n" $txt "" txt]} { incr num_lines }
|
||
return $num_lines
|
||
}
|
||
|
||
|
||
##
|
||
# Return 1 if token is a leaf
|
||
##
|
||
proc is_leaf { token } {
|
||
global tok_text
|
||
if {[regexp {<EFBFBD>.*<EFBFBD>} $tok_text($token) dummy]} {
|
||
return 0 }
|
||
return 1
|
||
}
|
||
|
||
|
||
##
|
||
# Return 1 if token is at the begin of a line
|
||
##
|
||
proc is_at_begin_of_line { token } {
|
||
global tok_text
|
||
while {$token != "content0"} {
|
||
set parent_token [get_parent $token]
|
||
|
||
if {[regexp "\n\\s*<EFBFBD>$token<EFBFBD>" $tok_text($parent_token) dummy]} {
|
||
return 1 }
|
||
|
||
if {[regexp "\[^\\s\].*<EFBFBD>$token<EFBFBD>" "$tok_text($parent_token)" dummy]} {
|
||
return 0 }
|
||
|
||
set token $parent_token
|
||
}
|
||
return 1
|
||
}
|
||
|
||
|
||
##
|
||
# Returns 1 if token is of one of the specified types
|
||
##
|
||
proc is_type { token types } {
|
||
foreach type $types {
|
||
if {[regexp "^$type\\d+" $token dummy]} { return 1 } }
|
||
return 0
|
||
}
|
||
|
||
|
||
##
|
||
# Return next leaf token, or "" if no leaf token exists
|
||
##
|
||
proc next_leaf { token } {
|
||
global tok_text
|
||
if {[is_leaf $token]} { return $token }
|
||
foreach tok [list_of_tokens $tok_text($token)] {
|
||
set leaf_token [next_leaf $tok]
|
||
if {$leaf_token != ""} { return $leaf_token }
|
||
}
|
||
return ""
|
||
}
|
||
|
||
|
||
##
|
||
# Convert string into a string containing only indentation and alignment
|
||
# characters
|
||
##
|
||
proc indent_filter { string } {
|
||
# regsub -all {[^\s]} $string " " string
|
||
return $string
|
||
}
|
||
|
||
|
||
##
|
||
# Return indentation and alignment of leaf token
|
||
##
|
||
proc indent_of {token} {
|
||
global tok_text
|
||
|
||
set leaf_indent ""
|
||
if {[is_leaf $token]} {
|
||
regexp {^([\t ]*)} $tok_text($token) dummy leaf_indent }
|
||
|
||
set parent [get_parent $token]
|
||
if {$parent == ""} {return ""}
|
||
set parent_text $tok_text($parent)
|
||
|
||
# expand all characters in front of our token
|
||
set prev ""
|
||
regexp "^(.*)<EFBFBD>$token<EFBFBD>" $parent_text dummy prev
|
||
set expanded_indent [expand $prev]
|
||
|
||
# if the expanded part of the parent token contains the newline, we are done
|
||
if {[regexp {\n} $expanded_indent dummy]} {
|
||
regexp {[^\n]*$} $expanded_indent indent_after_newline
|
||
return [indent_filter "$indent_after_newline$leaf_indent"] }
|
||
|
||
# keep searching for newline at the parent
|
||
return [indent_filter [indent_of $parent]$expanded_indent$leaf_indent]
|
||
}
|
||
|
||
|
||
##
|
||
# Return alignment level of token
|
||
##
|
||
proc align_level_of { token } {
|
||
regexp {[^\t]*$} [indent_of [next_leaf $token]] alignment
|
||
return [string length $alignment]
|
||
}
|
||
|
||
|
||
##
|
||
# Return indentation level of token
|
||
##
|
||
proc indent_level_of { token } {
|
||
regexp {^\t*} [indent_of [next_leaf $token]] indentation
|
||
return [string length $indentation]
|
||
}
|
||
|
||
|
||
proc hpos { token } {
|
||
return [expr [indent_level_of $token]*4 + [align_level_of $token]] }
|
||
|
||
|
||
##
|
||
# Find parent by depth search
|
||
##
|
||
proc get_parent {token} {
|
||
global tok_parent
|
||
if {[info exists tok_parent($token)] == 0} { return "" }
|
||
return $tok_parent($token)
|
||
}
|
||
|
||
|
||
##
|
||
# Return 1 if token in located within compound token
|
||
##
|
||
proc is_within { token compound } {
|
||
while {1} {
|
||
set parent [get_parent $token]
|
||
if {$parent == ""} { return 0 }
|
||
if {[is_type $parent $compound]} { return 1 }
|
||
set token $parent
|
||
}
|
||
}
|
||
|
||
|
||
##
|
||
# Return characters between token and next newline
|
||
##
|
||
proc trailing_chars_after { token } {
|
||
global tok_text
|
||
set parent [get_parent $token]
|
||
if {$parent == ""} { return "" }
|
||
|
||
regexp "<EFBFBD>$token<EFBFBD>(.*)\$" $tok_text($parent) dummy chars_after_token
|
||
|
||
# if parent has newline character after token, return number of characters until newline
|
||
if {[regexp "^(.*?)\\n" [expand $chars_after_token] dummy chars_until_newline]} {
|
||
return "$chars_until_newline" }
|
||
|
||
return "[expand $chars_after_token][trailing_chars_after $parent]"
|
||
}
|
||
|
||
|
||
##
|
||
# Calculate length of token, if merged on a single line
|
||
##
|
||
proc calc_merged_line_length { token } {
|
||
global tok_text
|
||
|
||
set string $tok_text($token)
|
||
|
||
# remove leading comment
|
||
regsub {^\s*<EFBFBD>m?lcomment\d+<EFBFBD>\n} $string "" string
|
||
|
||
set expanded [expand $string]
|
||
|
||
#
|
||
# Check if the entire token fits plus the tokens until the next newline
|
||
# fit on a single line
|
||
#
|
||
set token_len [string length $expanded]
|
||
set trailing_len [string length [trailing_chars_after $token]]
|
||
|
||
return [expr [hpos $token] + $token_len + $trailing_len]
|
||
}
|
||
|
||
|
||
|
||
############################
|
||
## Transformation helpers ##
|
||
############################
|
||
|
||
##
|
||
# Strip leading whitespace from first argument of a parenthesis block
|
||
#
|
||
# The parenthesis block can be a 'parenblk' or 'argparenblk'
|
||
##
|
||
proc strip_whitespace_from_first_argument { par_token } {
|
||
global tok_text
|
||
|
||
# tolerate newline directly after the parenthesis in function-call argument lists
|
||
if {[regexp {<EFBFBD>openparen\d+<EFBFBD>\n} $tok_text($par_token)] &&
|
||
[is_type [get_parent $par_token] function]} return
|
||
|
||
# strip whitespace residing in the parenthesis token
|
||
regsub {(<EFBFBD>openparen\d+<EFBFBD>)\s+} $tok_text($par_token) "\\1" tok_text($par_token)
|
||
|
||
#
|
||
# Further whitespace can be present within the first argument token.
|
||
# The par_token consists of 'openparen', arguments, and 'closeparen'.
|
||
# The arguments may be strings or identifiers. We just grab the
|
||
# second list element and squeeze it.
|
||
#
|
||
set firstarg_token [lindex [list_of_tokens $tok_text($par_token)] 1]
|
||
if {[is_at_begin_of_line $firstarg_token]} return
|
||
set firstarg_token [next_leaf $firstarg_token]
|
||
regsub {^[\t ]+} $tok_text($firstarg_token) "" tok_text($firstarg_token)
|
||
foreach tok [select_by_type {.*} $firstarg_token 1] {
|
||
if {[is_type $tok string]} continue
|
||
regsub -all {[\t ]+} $tok_text($tok) "" tok_text($tok) }
|
||
}
|
||
|
||
|
||
proc strip_whitespace_from_last_argument { par_token } {
|
||
global tok_text
|
||
|
||
# strip whitespace residing in the parenthesis token
|
||
regsub {[\t ]+(<EFBFBD>closeparen\d+<EFBFBD>)} $tok_text($par_token) "\\1" tok_text($par_token)
|
||
}
|
||
|
||
|
||
##
|
||
# Remove newline in front of specified token
|
||
#
|
||
# The argument must be a leaf token.
|
||
##
|
||
proc remove_newline_in_front_of { token {replacement " "} } {
|
||
global config_fix
|
||
global tok_text
|
||
if {$config_fix == 0} return
|
||
if {![is_at_begin_of_line $token]} return
|
||
|
||
# remove any alignment spaceing from token
|
||
regsub {^[\t ]+} $tok_text($token) "" tok_text($token)
|
||
|
||
set parent [get_parent $token]
|
||
if {$parent == ""} return
|
||
|
||
# remove leading non-newline whitespace from parent's token
|
||
regsub "\[\\t \]+(<EFBFBD>$token<EFBFBD>)" $tok_text($parent) "\\1" tok_text($parent)
|
||
|
||
# look out for the newline to eliminate, replace it
|
||
set pattern "\[\\t \]*\n\[\\t \]*(<EFBFBD>$token<EFBFBD>)"
|
||
if {[regexp $pattern $tok_text($parent) dummy]} {
|
||
regsub $pattern $tok_text($parent) "$replacement\\1" tok_text($parent)
|
||
return
|
||
}
|
||
|
||
# if there is no newline character at the parent, continue at the parent
|
||
if {[regexp "^<EFBFBD>$token<EFBFBD>" $tok_text($parent) dummy]} {
|
||
remove_newline_in_front_of $parent $replacement }
|
||
}
|
||
|
||
|
||
proc reindent { token } {
|
||
global indent_level
|
||
global align_level
|
||
set indent_level [indent_level_of $token]
|
||
set align_level [align_level_of $token]
|
||
indent_block $token
|
||
}
|
||
|
||
|
||
#######################
|
||
## Debugging support ##
|
||
#######################
|
||
|
||
proc dump_class_elems {class_token elem_type} {
|
||
global tok_text
|
||
|
||
set elem_tokens [select_by_type $elem_type $class_token 3]
|
||
|
||
if {![llength $elem_tokens]} { return }
|
||
|
||
puts stderr " $elem_type ([llength $elem_tokens]):"
|
||
foreach elem_token $elem_tokens {
|
||
set function_token [lindex [select_by_type function $elem_token] 0]
|
||
set name_token [lindex [select_by_type identifier $function_token] 0]
|
||
puts stderr " $tok_text($name_token)"
|
||
}
|
||
}
|
||
|
||
|
||
### PRINT INFORMATION ABOUT THE CLASSES AND THEIR MEMBER FUNCTIONS ###
|
||
proc dump_classes { } {
|
||
global tok_text
|
||
foreach class_token [select_by_type class] {
|
||
set name_token [lindex [select_by_type identifier $class_token] 0]
|
||
puts stderr "class $tok_text($name_token):"
|
||
|
||
foreach elem {constdecl constimpl destdecl destimpl funcdecl funcimpl} {
|
||
dump_class_elems $class_token $elem }
|
||
}
|
||
}
|
||
|
||
|
||
###################
|
||
## Preprocessing ##
|
||
###################
|
||
|
||
#
|
||
# Determine the parent of each token
|
||
#
|
||
|
||
foreach parent_tok [select_all] {
|
||
foreach tok [list_of_tokens $tok_text($parent_tok)] {
|
||
set tok_parent($tok) $parent_tok } }
|
||
|
||
#
|
||
# Transform syntax tree such that all indentations are located at
|
||
# leaf nodes. However, do not touch preprocessor macros. We won't
|
||
# attempt to reindent those.
|
||
#
|
||
|
||
foreach tok [select_all] {
|
||
if {[is_type $tok preproc]} continue
|
||
if {[is_leaf $tok] && [is_at_begin_of_line $tok]} {
|
||
set indent [indent_of $tok]
|
||
|
||
# remove remove whitespace from the tokens in front of the leaf
|
||
remove_newline_in_front_of $tok "\n"
|
||
|
||
# add indentation at the begin of the leaf token
|
||
regsub {^[\t ]*} $tok_text($tok) "$indent" tok_text($tok)
|
||
}
|
||
}
|
||
|
||
|
||
#########################
|
||
## Coding-style checks ##
|
||
#########################
|
||
|
||
#
|
||
# There are the following classes of complaints:
|
||
#
|
||
# Error - Intervention by the user is required,
|
||
# The style-checking process stops.
|
||
#
|
||
# Warning - Style conflicts that can be fixed automatically.
|
||
# The style-checking process continues.
|
||
#
|
||
# Suggestion - Non-essential style suggestions that can be followed
|
||
# automatically.
|
||
#
|
||
|
||
#
|
||
# Checking valid uses of preprocessor commands
|
||
#
|
||
|
||
msg "Checking preprocessor commands..."
|
||
|
||
set abort_after_preproc_check 0
|
||
foreach tok [select_by_type preproc] {
|
||
set parent_tok [get_parent $tok]
|
||
|
||
if {[is_type $parent_tok content]} continue
|
||
if {[is_type $parent_tok block]} {
|
||
if {[is_type [get_parent $parent_tok] namespaceblock]} continue
|
||
if {[is_type [get_parent $parent_tok] externcblk]} continue
|
||
}
|
||
|
||
error "preprocessor command not allowed at this location" $tok
|
||
set abort_after_preproc_check 1
|
||
}
|
||
if {$abort_after_preproc_check} {
|
||
error "further processing not possible because of errors above"
|
||
abort
|
||
}
|
||
|
||
#
|
||
# Check for C++ comments
|
||
#
|
||
|
||
msg "Checking absence of C++ comments..."
|
||
|
||
foreach tok [select_by_type cxxcomment] {
|
||
puts stderr "Warning at line $tok_line($tok): remove C++ comments, use /* traditional */ comment style"
|
||
}
|
||
|
||
#
|
||
# Perform indentation
|
||
#
|
||
|
||
msg "Checking indentation..."
|
||
|
||
##
|
||
# Generate string containing the white space for the given indentation and
|
||
# alignment
|
||
##
|
||
proc gen_indent { indent_level align_level } {
|
||
set indent ""
|
||
for { set i 0 } { $i < $indent_level } { incr i } { append indent "\t" }
|
||
for { set i 0 } { $i < $align_level } { incr i } { append indent " " }
|
||
return $indent;
|
||
}
|
||
|
||
|
||
##
|
||
# Indent multi-line comment
|
||
#
|
||
proc indent_mlcomment { mlcomment_token indent_level } {
|
||
global tok_text
|
||
set result {}
|
||
set cnt 0
|
||
foreach line [split $tok_text($mlcomment_token) "\n"] {
|
||
set alignment 0
|
||
if {$cnt > 0} { set alignment 1 }
|
||
|
||
set indentation [gen_indent $indent_level $alignment]
|
||
|
||
# handle single-line-style comments following code, i.e, a variable declaration
|
||
if {[is_at_begin_of_line $mlcomment_token] == 0} {
|
||
if {$cnt == 0} {
|
||
regexp {^[\t ]*} $line indentation
|
||
} else {
|
||
set align_level [expr [align_level_of $mlcomment_token] + 3]
|
||
set indentation [gen_indent [indent_level_of $mlcomment_token] $align_level]
|
||
}
|
||
}
|
||
|
||
regsub {^\s*(.*)$} $line "$indentation\\1" line
|
||
|
||
incr cnt
|
||
lappend result $line
|
||
}
|
||
return [join $result "\n"]
|
||
}
|
||
|
||
|
||
set alignment_stack {}
|
||
|
||
|
||
proc push_alignment { align_level } {
|
||
global alignment_stack
|
||
lappend alignment_stack $align_level
|
||
}
|
||
|
||
|
||
proc pop_alignment { } {
|
||
global alignment_stack
|
||
set top [lindex $alignment_stack end]
|
||
set alignment_stack [lreplace $alignment_stack end end]
|
||
return $top
|
||
}
|
||
|
||
|
||
##
|
||
# Return true if statement is a non-block single statement to be indented
|
||
##
|
||
proc is_single_indented_statement { token } {
|
||
global tok_text
|
||
|
||
if {![is_at_begin_of_line [next_leaf $token]]} { return 0 }
|
||
if {![is_type $token statement] && ![is_type $token lcomment]} { return 0 }
|
||
|
||
# indent line comment only if it is the first of its parent
|
||
if {[is_type $token lcomment]} {
|
||
if {[regexp "<EFBFBD>$token<EFBFBD>\\s*<EFBFBD>keyelse\\d+<EFBFBD>" $tok_text([get_parent $token]) dummy]} {
|
||
return 0 } }
|
||
|
||
# child of statement must not be a block
|
||
if {[llength [select_by_type block $token 1]] > 0} { return 0 }
|
||
|
||
# parent must be 'if', 'ifelse', or 'for' token
|
||
if {[is_type [get_parent $token] {if while ifelse for}]} { return 1 }
|
||
|
||
return 0
|
||
}
|
||
|
||
|
||
proc is_indented_assignment { block_token } {
|
||
global tok_text
|
||
if {[llength [select_by_type {assign\w*} $block_token 1]] == 0} { return 0 }
|
||
return [regexp {<EFBFBD>assign\w*\d+<EFBFBD>[\t ]*\n} $tok_text($block_token) dummy]
|
||
}
|
||
|
||
|
||
proc first_init_elem { initializer_token } {
|
||
global tok_text
|
||
return [lindex [list_of_tokens $tok_text($initializer_token)] 1]
|
||
}
|
||
|
||
|
||
proc is_normal_assignment { block_token } {
|
||
foreach compound {argparenblk enum virtassign} {
|
||
if {[is_type $block_token $compound] || [is_within $block_token $compound]} {
|
||
return 0 } }
|
||
if {[llength [select_by_type {assign\w*} $block_token 1]] > 0} { return 1 }
|
||
return 0
|
||
}
|
||
|
||
|
||
proc is_followed_by_space { token } {
|
||
global tok_text
|
||
return [regexp "<EFBFBD>$token<EFBFBD>\[\t \]" $tok_text([get_parent $token]) dummy]
|
||
}
|
||
|
||
|
||
proc is_indented_parenblk { parenblk } {
|
||
global tok_text
|
||
if {[is_type $parenblk parenblk] == 0} { return 0 }
|
||
|
||
# if the opening parenthesis is followed by a newline, we indent the content
|
||
if {[regexp {<EFBFBD>openparen\d+<EFBFBD>\n} $tok_text($parenblk) dummy]} { return 1 }
|
||
|
||
return 0
|
||
}
|
||
|
||
|
||
proc is_comment_within_switch { token } {
|
||
if {[is_type $token {lcomment mlcomment}] &&
|
||
[is_type [get_parent $token] codeseq] &&
|
||
[is_type [get_parent [get_parent $token]] block] &&
|
||
[is_type [get_parent [get_parent [get_parent $token]]] statement] &&
|
||
[is_type [get_parent [get_parent [get_parent [get_parent $token]]]] switch]} { return 1 }
|
||
return 0
|
||
}
|
||
|
||
|
||
proc indent_block { block_token } {
|
||
global indent_level
|
||
global align_level
|
||
global tok_text
|
||
global tok_line
|
||
global config_fix
|
||
global depth
|
||
|
||
if {[is_type $block_token mlcomment]} {
|
||
if {$config_fix} {
|
||
set tok_text($block_token) [indent_mlcomment $block_token $indent_level]
|
||
}
|
||
return
|
||
}
|
||
|
||
# preprocessor macros are never indented
|
||
if {[is_type $block_token preproc]} {
|
||
if {$config_fix} {
|
||
set tok [next_leaf $block_token]
|
||
regsub {^\s*} $tok_text($tok) "" tok_text($tok)
|
||
}
|
||
return
|
||
}
|
||
|
||
if {[is_leaf $block_token] && [is_at_begin_of_line $block_token]} {
|
||
set curr_indent ""
|
||
regexp {^[\t ]*} $tok_text($block_token) curr_indent
|
||
set expected_indent [gen_indent $indent_level $align_level]
|
||
|
||
# preserve alignment of certain operators
|
||
if {[is_type $block_token {lshift rshift plus minus}]} {
|
||
set expected_indent [gen_indent $indent_level [align_level_of $block_token]]
|
||
}
|
||
|
||
if {$curr_indent != $expected_indent} {
|
||
set align_msg ""
|
||
if {$align_level > 0} {
|
||
set align_msg " and $align_level spaces" }
|
||
warn "wrong indentation, please change to $indent_level tabs$align_msg" $block_token
|
||
regsub {^[\t ]+} $tok_text($block_token) [gen_indent $indent_level $align_level] tok_text($block_token)
|
||
}
|
||
return
|
||
}
|
||
|
||
#
|
||
# Process non-leaf token
|
||
#
|
||
if {[is_type $block_token {protected private public}]} { incr indent_level }
|
||
if {[is_type $block_token inherit]} {
|
||
push_alignment $align_level
|
||
set align_level [expr [align_level_of [next_leaf $block_token]] + 2]
|
||
}
|
||
foreach tok [select_by_type {.*} $block_token 1] {
|
||
|
||
if {[is_type $tok {"assign\\w*"}] && [is_normal_assignment $block_token]} {
|
||
push_alignment $align_level
|
||
if {[is_indented_assignment $block_token]} {
|
||
incr indent_level
|
||
set align_level 0
|
||
} else {
|
||
set align_level [expr [align_level_of $tok] + 2]
|
||
}
|
||
}
|
||
if {[is_type $tok typename] && [is_type $block_token typedef]} {
|
||
push_alignment $align_level
|
||
set align_level 8
|
||
}
|
||
if {[is_type $tok closeparen]} {
|
||
if {[is_indented_parenblk $block_token]} { incr indent_level -1 }
|
||
set align_level [pop_alignment]
|
||
}
|
||
if {[is_type $tok closebrace]} { incr indent_level -1 }
|
||
if {[is_type $tok {label caselabel publiclabel privatelabel protectedlabel}]} { incr indent_level -1 }
|
||
if {[is_comment_within_switch $tok]} { incr indent_level -1 }
|
||
if {[is_single_indented_statement $tok]} { incr indent_level }
|
||
if {[is_at_begin_of_line $tok] && [is_followed_by_space $tok]} {
|
||
if {[is_type $tok {or and}]} { incr align_level -3}
|
||
if {[is_type $tok {bitor amper plus minus question}]} { incr align_level -2}
|
||
}
|
||
|
||
indent_block $tok
|
||
|
||
if {[is_type $tok identifier] && [is_type $block_token vardecl]} {
|
||
|
||
# handle only the first identifier of a vardecl
|
||
if {[lindex [list_of_tokens $tok_text($block_token)] 0] == $tok} {
|
||
push_alignment $align_level
|
||
|
||
#
|
||
# Align subsequent lines of variable declaration at the
|
||
# second identifier, which should be the name of the
|
||
# first variable.
|
||
#
|
||
set second_token [lindex [list_of_tokens $tok_text($block_token)] 1]
|
||
set align_level [align_level_of [next_leaf $second_token]]
|
||
}
|
||
}
|
||
|
||
if {[is_at_begin_of_line $tok] && [is_followed_by_space $tok]} {
|
||
if {[is_type $tok {or and}]} { incr align_level 3}
|
||
if {[is_type $tok {bitor amper plus minus}]} { incr align_level 2}
|
||
}
|
||
|
||
if {[is_type $tok keyreturn]} {
|
||
push_alignment $align_level
|
||
set align_level 7
|
||
}
|
||
|
||
if {[is_single_indented_statement $tok]} { incr indent_level -1 }
|
||
if {[is_type $tok {label caselabel publiclabel privatelabel protectedlabel}]} { incr indent_level }
|
||
if {[is_comment_within_switch $tok]} { incr indent_level }
|
||
if {[is_type $tok openbrace]} { incr indent_level }
|
||
if {[is_type $tok openparen]} {
|
||
push_alignment $align_level
|
||
if {[is_indented_parenblk $block_token]} {
|
||
set align_level 0
|
||
incr indent_level
|
||
} else {
|
||
set align_level [expr [align_level_of $tok] + 1]
|
||
}
|
||
}
|
||
if {[is_type $tok colon] && [is_type $block_token initializer]} {
|
||
if {[align_level_of [first_init_elem $block_token]] > 0} {
|
||
push_alignment $align_level
|
||
set align_level [align_level_of [first_init_elem $block_token]]
|
||
} else {
|
||
incr indent_level
|
||
}
|
||
}
|
||
}
|
||
if {[is_type $block_token {protected private public}]} { incr indent_level -1 }
|
||
if {[is_type $block_token {inherit typedef return vardecl}]} { set align_level [pop_alignment] }
|
||
if {[is_normal_assignment $block_token]} {
|
||
|
||
#
|
||
# one block token may contain multiple assign tokens, revert
|
||
# indentation for each of them
|
||
#
|
||
foreach assign [select_by_type {assign\w*} $block_token] {
|
||
set align_level [pop_alignment]
|
||
if {[is_indented_assignment $block_token]} { incr indent_level -1 }
|
||
}
|
||
}
|
||
if {[is_type $block_token initializer]} {
|
||
if {[align_level_of [first_init_elem $block_token]] > 0} {
|
||
set align_level [pop_alignment]
|
||
} else {
|
||
incr indent_level -1
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
set indent_level 0
|
||
set align_level 0
|
||
indent_block content0
|
||
|
||
#abort
|
||
msg "Checking file header..."
|
||
|
||
#
|
||
# Check empty space in front of file header
|
||
#
|
||
|
||
if {[regexp {^\s+} $tok_text(content0) dummy]} {
|
||
warn "empty space before file header at the beginning of the file"
|
||
if {$config_fix} {
|
||
regsub {^\s+} $tok_text(content0) "" tok_text(content0) }
|
||
}
|
||
|
||
#
|
||
# Check existence of file header
|
||
#
|
||
|
||
proc file_header_template { } {
|
||
set res ""
|
||
append res "/*\n"
|
||
append res " * \\brief Brief description of the file\n"
|
||
append res " * \\author Name of Author\n"
|
||
append res " * \\date [exec date --iso-8601]\n"
|
||
append res " */\n"
|
||
append res "#warning Style: please fill out the file header and remove this warning\n\n"
|
||
return $res
|
||
}
|
||
|
||
if {![regexp {^<EFBFBD>mlcomment\d+<EFBFBD>} $tok_text(content0) dummy]} {
|
||
error "expect file header at the beginning of the file"
|
||
if {$config_fix} {
|
||
regsub {^(<EFBFBD>(tab|space|align|line)\d+<EFBFBD>)*} $tok_text(content0) [file_header_template] tok_text(content0) }
|
||
abort
|
||
}
|
||
|
||
#
|
||
# Inspect file header
|
||
#
|
||
|
||
proc check_author { header_line } {
|
||
# author
|
||
if {[regexp {^ \* \\author([\t ]+)([^\t ].*)} $header_line dummy align author] == 0} {
|
||
warn "malformed author field in file header"
|
||
return
|
||
}
|
||
if {[string length $author] < 2} {
|
||
warn "incomplete author field in file header"
|
||
}
|
||
if {$align != " "} {
|
||
warn "unaligned author field in file header"
|
||
set align " "
|
||
}
|
||
if {[string is lower [string index $author 0]]} {
|
||
warn "author name should start with an upper-case character"
|
||
set author [string toupper $author 0 0]
|
||
}
|
||
return " * \\author$align$author"
|
||
}
|
||
|
||
proc check_file_header { } {
|
||
global tok_text
|
||
global config_fix
|
||
set header_token [lindex [list_of_tokens $tok_text(content0)] 0]
|
||
set header [expand_token $header_token]
|
||
set header_lines [split $header "\n"]
|
||
set cnt 0
|
||
|
||
# first line
|
||
if {[lindex $header_lines 0] != "/*"} {
|
||
warn "malformed first line of file header"
|
||
lset header_lines 0 "/*"
|
||
}
|
||
|
||
# brief description
|
||
if {[regexp {^ \* \\brief(\s+)([^\s].*)} [lindex $header_lines 1] dummy align desc] == 0} {
|
||
warn "malformed brief description in file header"
|
||
return
|
||
}
|
||
if {[string length $desc] < 2} {
|
||
warn "incomplete brief description in file header"
|
||
}
|
||
if {$align != " "} {
|
||
warn "unaligned brief description in file header"
|
||
set align " "
|
||
}
|
||
if {[string is lower [string index $desc 0]]} {
|
||
warn "brief description of file header should start with an upper-case character"
|
||
set desc [string toupper $desc 0 0]
|
||
}
|
||
lset header_lines 1 " * \\brief$align$desc"
|
||
|
||
set line_cnt 2
|
||
|
||
while {[regexp {\\author} [lindex $header_lines $line_cnt] dummy]} {
|
||
lset header_lines $line_cnt [check_author [lindex $header_lines $line_cnt]]
|
||
incr line_cnt
|
||
}
|
||
|
||
# date
|
||
if {[regexp {^ \* \\date([\t ]+)([^\t ].*)} [lindex $header_lines $line_cnt] dummy align date] == 0} {
|
||
warn "malformed date field in file header"
|
||
return
|
||
}
|
||
if {[regexp {^\d\d\d\d-\d\d-\d\d$} $date dummy] == 0} {
|
||
warn "date in file header not in format YYYY-MM-DD"
|
||
|
||
# attempt to convert german date to YYYY-MM-DD
|
||
if {[regexp {(\d\d)\.(\d\d)\.(\d\d\d\d)} $date dummy day month year]} {
|
||
if {$month < 13} { set date "$year-$month-$day" }
|
||
}
|
||
}
|
||
if {$align != " "} {
|
||
warn "unaligned date field in file header"
|
||
set align " "
|
||
}
|
||
lset header_lines $line_cnt " * \\date$align$date"
|
||
incr line_cnt
|
||
|
||
if {$config_fix} {
|
||
set tok_text($header_token) [join $header_lines "\n"] }
|
||
}
|
||
|
||
check_file_header
|
||
|
||
#
|
||
# Check for single empty line after file header
|
||
#
|
||
|
||
if {[regexp {^<EFBFBD>mlcomment\d+<EFBFBD>\n\n\n+} $tok_text(content0) dummy]} {
|
||
warn "expect single empty line after file header"
|
||
if {$config_fix} {
|
||
regsub {^(<EFBFBD>mlcomment\d+<EFBFBD>\n)\n+} $tok_text(content0) "\\1\n" tok_text(content0) }
|
||
}
|
||
|
||
msg "Checking names of classes, functions, and variables..."
|
||
|
||
#
|
||
# Private members must start with an underscore
|
||
#
|
||
|
||
proc vardecl_name { vardecl_token } {
|
||
global tok_text
|
||
if {[is_type $vardecl_token vardecl] == 0} return ""
|
||
# the variable name is the second identifier of the vardecl token
|
||
set name [lindex [select_by_type identifier $vardecl_token 1] 1]
|
||
if {$name == ""} { return "" }
|
||
return $tok_text($name)
|
||
}
|
||
|
||
proc funcsignature_name { funcsignature_token } {
|
||
global tok_text
|
||
if {[is_type $funcsignature_token funcsignature] == 0} return ""
|
||
return $tok_text([lindex [select_by_type identifier $funcsignature_token 1] 0])
|
||
}
|
||
|
||
foreach prot_type {private protected} {
|
||
foreach prot [select_by_type $prot_type] {
|
||
foreach vardecl [select_by_type vardecl $prot 2] {
|
||
if {[regexp {^_} [vardecl_name $vardecl]]} continue
|
||
error "$prot_type member variable name '[vardecl_name $vardecl]' should start with an underscore" $vardecl
|
||
}
|
||
|
||
foreach funcsignature [select_by_type funcsignature $prot 3] {
|
||
if {[regexp {^_} [funcsignature_name $funcsignature]]} continue
|
||
if {[is_type [get_parent $funcsignature] {constdecl constimpl destdecl destimpl}]} continue
|
||
error "$prot_type member function name '[funcsignature_name $funcsignature]' should start with an underscore" $funcsignature
|
||
}
|
||
}
|
||
}
|
||
|
||
#
|
||
# Variables and functions must not contain upper-case characters
|
||
#
|
||
|
||
foreach vardecl [select_by_type vardecl] {
|
||
if {[regexp {[A-Z]} [vardecl_name $vardecl] dummy]} {
|
||
error "variable name must not contain upper-case characters" $vardecl } }
|
||
|
||
# do not look at funcsignature tokens of constructors and destructors
|
||
foreach func_type "[select_by_type funcdecl] [select_by_type funcimpl]" {
|
||
foreach funcsignature [select_by_type funcsignature $func_type 1] {
|
||
if {[regexp {[A-Z]} [funcsignature_name $funcsignature] dummy]} {
|
||
error "function name must not contain upper-case characters" $funcsignature } }
|
||
}
|
||
|
||
msg "Checking for superfluous semicolons..."
|
||
|
||
#
|
||
# Check for non-needed trailing semicolons
|
||
#
|
||
|
||
foreach tok "content0 [select_by_type namespaceblock]" {
|
||
set txt $tok_text($tok)
|
||
while {[regexp {<EFBFBD>(namespace\d+)<EFBFBD>\s*;+} $txt dummy ns]} {
|
||
set ns_name [select_by_type identifier $ns 1]
|
||
warn "unneeded trailing ';' after name-space block of '$tok_text($ns_name)'"
|
||
regsub {(<EFBFBD>namespace\d+<EFBFBD>)\s*;+} $txt {\1} txt
|
||
}
|
||
|
||
if {$config_fix} {
|
||
set tok_text($tok) $txt }
|
||
}
|
||
|
||
foreach tok_type {funcimpl constimpl destimpl} {
|
||
foreach tok [select_by_type $tok_type] {
|
||
|
||
if {[regexp {[\s;]+$} $tok_text($tok) dummy] == 0} continue
|
||
|
||
warn "superfluous characters after implementation block" $tok
|
||
|
||
if {$config_fix} {
|
||
regsub {[\s;]+$} $tok_text($tok) "" tok_text($tok)
|
||
}
|
||
}
|
||
}
|
||
|
||
#
|
||
# Check proper use of single spaces
|
||
#
|
||
|
||
msg "Checking for correct spacing..."
|
||
|
||
proc check_single_spaces {env_token
|
||
tok_type tok_type_name
|
||
tok_type_next tok_type_name_next
|
||
{error_message "Getting confused"}} {
|
||
global tok_text config_fix
|
||
|
||
if {[regexp "<EFBFBD>($tok_type\\d+)<EFBFBD>(\\s*)<EFBFBD>($tok_type_next\\d+)<EFBFBD>" $tok_text($env_token) dummy tok ws next_token]} {
|
||
if {$ws != " "} {
|
||
warn "Use single space between $tok_type_name and $tok_type_name_next" $tok
|
||
if {$config_fix} {
|
||
regsub "(<EFBFBD>$tok_type\\d+<EFBFBD>)\\s*(<EFBFBD>$tok_type_next\\d+<EFBFBD>)" $tok_text($env_token) "\\1 \\2" tok_text($env_token) }
|
||
}
|
||
} else {
|
||
abort "$error_message at line $tok_line($env_token)" }
|
||
}
|
||
|
||
# between namespace name and opening brace
|
||
foreach tok [select_by_type namespace] {
|
||
set namespace_name [expand_token [lindex [select_by_type identifier $tok] 0]]
|
||
check_single_spaces $tok identifier "namespace name \"$namespace_name\"" \
|
||
namespaceblock "opening brace" \
|
||
"Invalid namespace definition"
|
||
}
|
||
|
||
# no space after function names
|
||
foreach tok_type {function funcsignature funcptr destfunction} {
|
||
foreach tok [select_by_type $tok_type] {
|
||
set pattern {\s+<EFBFBD>((parenblk|argparenblk)\d+)<EFBFBD>}
|
||
if {[regexp $pattern $tok_text($tok) dummy paren_token dummy] == 0} continue
|
||
|
||
warn "superfluous space between function name and parenthesis" $tok
|
||
if {$config_fix} {
|
||
regsub $pattern $tok_text($tok) "<EFBFBD>\\1<EFBFBD>" tok_text($tok)
|
||
set leaf [next_leaf $paren_token]
|
||
regsub {^\s*} $tok_text($leaf) "" tok_text($leaf)
|
||
}
|
||
|
||
#
|
||
# We change the indentation of an open parenthesis,
|
||
# so we must reindent the whole block.
|
||
#
|
||
reindent $paren_token
|
||
}
|
||
}
|
||
|
||
|
||
# superfluous space within a parenthesis block
|
||
foreach par_type {parenblk argparenblk} {
|
||
foreach par_token [select_by_type $par_type] {
|
||
|
||
# tolerate extra whitspaces in for and function statements
|
||
if {[is_type [get_parent $par_token] {forcond function}]} continue
|
||
|
||
set string [expand_token $par_token]
|
||
|
||
if {[regexp {\(\s+} $string dummy]} {
|
||
warn "leading whitespace in parenthesis block" $par_token
|
||
if {$config_fix} { strip_whitespace_from_first_argument $par_token }
|
||
}
|
||
if {[regexp {\s+\)} $string dummy]} {
|
||
warn "trailing whitespace in parenthesis block" $par_token
|
||
if {$config_fix} { strip_whitespace_from_last_argument $par_token }
|
||
}
|
||
}
|
||
}
|
||
|
||
#
|
||
# Check proper use of empty lines
|
||
#
|
||
|
||
##
|
||
# Check if there is one empty line before the specified token
|
||
#
|
||
# \param min if set to 0, accept less than one line
|
||
# \parem max if set to 0, accept more than one line
|
||
##
|
||
proc check_empty_line_before {token tok_type_name {min 1} {max 1}} {
|
||
global tok_text
|
||
global config_fix
|
||
|
||
# walk up the parent tree until we see our left context
|
||
set parent_token [get_parent $token]
|
||
while {[regexp "^<EFBFBD>$token<EFBFBD>" $tok_text($parent_token)]} {
|
||
set token $parent_token
|
||
set parent_token [get_parent $token]
|
||
if {$parent_token == ""} return
|
||
}
|
||
|
||
set parent_text $tok_text($parent_token)
|
||
|
||
if {$max && [regexp "\n\n\n<EFBFBD>$token<EFBFBD>" $parent_text dummy]} {
|
||
warn "expected only one empty line before $tok_type_name" $token
|
||
regsub "\n+<EFBFBD>$token<EFBFBD>" $parent_text "\n\n<EFBFBD>$token<EFBFBD>" parent_text
|
||
}
|
||
|
||
if {$min && [regexp "\[^\n\]\n<EFBFBD>$token<EFBFBD>" $parent_text dummy]} {
|
||
warn "missing one empty line before $tok_type_name" $token
|
||
regsub "\n+<EFBFBD>$token<EFBFBD>" $parent_text "\n\n<EFBFBD>$token<EFBFBD>" parent_text
|
||
}
|
||
|
||
if {$config_fix} { set tok_text($parent_token) $parent_text }
|
||
}
|
||
|
||
|
||
proc check_empty_line_after {env_token tok_type tok_type_name} {
|
||
global tok_text config_fix
|
||
|
||
set txt $tok_text($env_token)
|
||
while {[regexp "<EFBFBD>($tok_type\\d+)<EFBFBD>((\[^\n\])|(\n\[^\n\])|(\n{3}))" $txt dummy tok next]} {
|
||
warn "Expect one empty line after $tok_type_name" $tok
|
||
regsub "(<EFBFBD>$tok_type\\d+<EFBFBD>)(\n)*" $txt "\\1\n\n" txt
|
||
}
|
||
if {$config_fix} {
|
||
set tok_text($env_token) $txt }
|
||
}
|
||
|
||
# empty line after protection-scope labels
|
||
foreach p {public private protected} {
|
||
foreach tok [select_by_type $p] {
|
||
check_empty_line_after $tok label "\"$p:\" label" } }
|
||
|
||
# empty line before protection-scope labels
|
||
foreach p {public private protected} {
|
||
foreach tok [select_by_type $p] {
|
||
check_empty_line_before $tok "\"$p:\" label" 0 1 } }
|
||
|
||
# empty line at beginning of name space
|
||
foreach tok [select_by_type namespaceblock] {
|
||
|
||
#
|
||
# Allow for the special case of having a bunch of
|
||
# includes within a namespace, otherwise check for
|
||
# an empty line.
|
||
#
|
||
if {![regexp {^<EFBFBD>openbrace\d+<EFBFBD>\s<EFBFBD>preproc\d+<EFBFBD>} $tok_text($tok)]} {
|
||
if {[count_line_breaks $tok] > "1"} {
|
||
check_empty_line_after $tok openbrace "opening brace of name space" } }
|
||
}
|
||
|
||
|
||
##
|
||
# Return 1 if token is the first token of a block
|
||
##
|
||
proc is_first_token_of_block { token } {
|
||
global tok_text
|
||
foreach block_type {block parenblk classblock enumblock} {
|
||
|
||
#
|
||
# Walk up compound tokens until we find a block or
|
||
# find another token in front of us.
|
||
#
|
||
while {1} {
|
||
set parent [get_parent $token]
|
||
if {[is_type $parent $block_type]} {
|
||
|
||
#
|
||
# A block starts with a brace or parenthesis. We are interested
|
||
# in the second token.
|
||
#
|
||
if {[lindex [list_of_tokens $tok_text($parent)] 1] == $token} {
|
||
return 1 }
|
||
break
|
||
}
|
||
if {[lindex [list_of_tokens $tok_text($parent)] 0] != $token} {
|
||
break }
|
||
set token $parent
|
||
}
|
||
}
|
||
return 0
|
||
}
|
||
|
||
# empty line between member-functions
|
||
foreach tok_type { { funcdecl "function declaration" 0 }
|
||
{ funcimpl "function" 0 }
|
||
{ constdecl "constructor declaration" 0 }
|
||
{ constimpl "constructor" 0 }
|
||
{ destdecl "destructor declaration" 0 }
|
||
{ destimpl "destructor" 0 }
|
||
{ lcomment "single-line comment" 1 } } {
|
||
|
||
foreach tok [select_by_type [lindex $tok_type 0]] {
|
||
if {[is_type [get_parent $tok] namespaceblock]} continue
|
||
if {[is_type [get_parent $tok] content]} continue
|
||
if {[is_at_begin_of_line $tok] == 0} continue
|
||
if {[is_first_token_of_block $tok]} continue
|
||
set message [lindex $tok_type 1]
|
||
set test_min [lindex $tok_type 2]
|
||
check_empty_line_before $tok $message $test_min
|
||
}
|
||
}
|
||
|
||
#
|
||
# Check absence of spacing around certain binary operators
|
||
#
|
||
|
||
foreach identifier [select_by_type identifier] {
|
||
foreach operator {deref dot doublecolon} {
|
||
set string $tok_text($identifier)
|
||
|
||
# only look at binary operators
|
||
if {[regexp "\[^\\s\].*<EFBFBD>$operator\\d+<EFBFBD>.*\[^\\s\]" $string dummy] == 0} continue
|
||
|
||
# check for space left of operator
|
||
if {[regexp "\[\\t \]+<EFBFBD>$operator\\d+<EFBFBD>" $string dummy]} {
|
||
warn "superfluous whitespace in front of '->' operator" $identifier
|
||
regsub "\[\\t \]+(<EFBFBD>$operator\\d+<EFBFBD>)" $string {\1} string
|
||
}
|
||
|
||
# check for space right of operator
|
||
while {[regexp -- "<EFBFBD>$operator\\d+<EFBFBD>\[\\t \]+" $string dummy]} {
|
||
warn "superfluous whitespace after '->' operator" $tok
|
||
regsub -- "(<EFBFBD>$operator\\d+<EFBFBD>)\[\\t \]+" $string {\1} string
|
||
}
|
||
if {$config_fix} { set tok_text($identifier) $string }
|
||
}
|
||
}
|
||
|
||
#
|
||
# Check for trailing spaces
|
||
#
|
||
|
||
msg "Checking for trailing spaces..."
|
||
|
||
foreach tok [select_all] {
|
||
set lines [split $tok_text($tok) "\n"]
|
||
if {[llength $lines] < 2} continue
|
||
|
||
set result {}
|
||
set cnt 0
|
||
set expanded ""
|
||
foreach line $lines {
|
||
|
||
append expanded [expand $line]
|
||
|
||
if {$cnt < [expr [llength $lines] - 1]} {
|
||
if {[regexp {\s+$} $line dummy]} {
|
||
set num_newlines [regexp -all {\n} $expanded dummy]
|
||
set line_num [expr $tok_line($tok) + $num_newlines + $cnt]
|
||
puts stderr "Warning at line $line_num: trailing space"
|
||
if {$config_fix} {
|
||
regsub {\s+$} $line "" line }
|
||
}
|
||
}
|
||
lappend result $line
|
||
incr cnt
|
||
}
|
||
if {$config_fix} { set tok_text($tok) [join $result "\n"]}
|
||
}
|
||
|
||
#
|
||
# Check for superfluous leading and spaces in single-line comments
|
||
#
|
||
|
||
foreach tok [select_by_type lcomment] {
|
||
if {[regexp {/\* +} $tok_text($tok)] == 0} continue
|
||
|
||
warn "Warning: superfluous leading space in comment" $tok
|
||
if {$config_fix} {
|
||
regsub {/\* +} $tok_text($tok) {/* } tok_text($tok) }
|
||
}
|
||
|
||
msg "Checking placement of braces and parenthesis..."
|
||
|
||
#
|
||
# Check for brace placement after 'if', 'for', 'switch', 'while', etc.
|
||
#
|
||
|
||
foreach block [select_by_type block] {
|
||
set openbrace [select_by_type openbrace $block 1]
|
||
if {![is_at_begin_of_line $openbrace]} continue
|
||
|
||
#
|
||
# Each block is wrapped in a statement. We have to inspect the
|
||
# parent of the statement.
|
||
#
|
||
set types_to_check {if for ifelse switch while}
|
||
if {![is_type [get_parent [get_parent $block]] $types_to_check]} {
|
||
continue }
|
||
|
||
warn "put opening brace to previous line" $block
|
||
remove_newline_in_front_of [next_leaf $block]
|
||
}
|
||
|
||
#
|
||
# Check for absence of newline between enum and opening brace
|
||
#
|
||
|
||
foreach enumblock [select_by_type enumblock] {
|
||
if {![is_at_begin_of_line $enumblock]} continue
|
||
|
||
warn "put opening brace to previous line" $enumblock
|
||
remove_newline_in_front_of [next_leaf $enumblock]
|
||
}
|
||
|
||
#
|
||
# Check for single space after keywords 'if', 'for', 'switch', 'while'
|
||
#
|
||
|
||
foreach type {if for while switch catch} {
|
||
set tok_type "cond"
|
||
set tok_type "$type$tok_type"
|
||
foreach tok [select_by_type $tok_type] {
|
||
if {[regexp "<EFBFBD>key$type\\d+<EFBFBD> <EFBFBD>(parenblk\\d+)<EFBFBD>" $tok_text($tok) dummy]} continue
|
||
|
||
warn "use one space after after '$type'" $tok
|
||
|
||
if {$config_fix} {
|
||
regexp {<EFBFBD>(parenblk\d+)<EFBFBD>} $tok_text($tok) dummy parenblk
|
||
regsub "\\s*(<EFBFBD>parenblk\\d+<EFBFBD>)" $tok_text($tok) { \1} tok_text($tok)
|
||
set leaf [next_leaf $parenblk]
|
||
regsub {^\s*} $tok_text($leaf) "" tok_text($leaf)
|
||
reindent $tok
|
||
}
|
||
}
|
||
}
|
||
|
||
#
|
||
# Check for newline after opening and in front of closing braces
|
||
#
|
||
|
||
foreach impl_type {funcimpl constimpl destimpl} {
|
||
foreach impl [select_by_type $impl_type] {
|
||
if {[regexp {<EFBFBD>funcsignature\d+<EFBFBD>\n} $tok_text($impl)]} continue
|
||
if {[regexp {<EFBFBD>funcsignature\d+<EFBFBD>[\t ]*<EFBFBD>initializer\d+<EFBFBD>} $tok_text($impl)]} continue
|
||
|
||
# tolerate single-line or double-line implementations
|
||
set text $tok_text($impl)
|
||
regsub {^([\t ]*)<EFBFBD>m?lcomment\d+<EFBFBD>} $text {\1} text
|
||
set expanded [expand $text]
|
||
if {[regexp -all {\n} $expanded dummy] < 2} continue
|
||
if {[calc_merged_line_length $impl] < 79} continue
|
||
|
||
warn "missing newline after function signature" $impl
|
||
|
||
if {$config_fix == 0} continue
|
||
|
||
set indent [gen_indent [indent_level_of [next_leaf $impl]] 0]
|
||
regsub {(<EFBFBD>funcsignature\d+<EFBFBD>)\s*} $tok_text($impl) "\\1\n$indent" tok_text($impl)
|
||
}
|
||
}
|
||
|
||
#
|
||
# Check if the closing brace of an single open brace is single too
|
||
#
|
||
foreach block_type {block classblock enumbloc} {
|
||
foreach block [select_by_type $block_type] {
|
||
|
||
if {[is_at_begin_of_line $block] == 0} continue
|
||
|
||
# if close brace follows a newline, we are fine
|
||
if {[regexp {\n[\t ]*<EFBFBD>closebrace\d+<EFBFBD>} $tok_text($block) dummy]} continue
|
||
|
||
# if block is empty and only one space is used, we are fine
|
||
if {[regexp {<EFBFBD>openbrace\d+<EFBFBD> <EFBFBD>closebrace\d+<EFBFBD>} $tok_text($block) dummy]} continue
|
||
|
||
if {[regexp {<EFBFBD>openbrace\d+<EFBFBD>(\s\s|)<EFBFBD>closebrace\d+<EFBFBD>} $tok_text($block) dummy]} {
|
||
warn "use one space within empty block" $block
|
||
regsub -all {(<EFBFBD>openbrace\d+<EFBFBD>)(\s\s|)(<EFBFBD>closebrace\d+<EFBFBD>)} $tok_text($block) {\1 \2} tok_text($block)
|
||
}
|
||
|
||
warn "put closing brace of block at a new line" $block
|
||
|
||
if {$config_fix == 0} continue
|
||
|
||
regsub {\s*(<EFBFBD>closebrace\d+<EFBFBD>)} $tok_text($block) "\n\\1" tok_text($block)
|
||
set closebrace [select_by_type closebrace $block 1]
|
||
regsub {^} $tok_text($closebrace) "[indent_of $block]" tok_text($closebrace)
|
||
}
|
||
}
|
||
|
||
#
|
||
# No newlines after free-standing opening braces
|
||
#
|
||
|
||
foreach block_type {block classblock enumblock} {
|
||
foreach block [select_by_type $block_type] {
|
||
|
||
if {[is_at_begin_of_line $block] == 0} continue
|
||
|
||
if {[regexp {<EFBFBD>(openbrace\d+)<EFBFBD>[\t ]*\n[\ ]*\n} $tok_text($block) dummy openbrace] == 0} {
|
||
continue }
|
||
|
||
warn "superfluous empty line after opening brace" $block
|
||
|
||
if {$config_fix == 0} continue
|
||
|
||
regsub {<EFBFBD>(openbrace\d+)<EFBFBD>\s*} $tok_text($block) "<EFBFBD>\\1<EFBFBD>\n" tok_text($block)
|
||
}
|
||
}
|
||
|
||
#
|
||
# Check for free-standing closing parenthesis
|
||
#
|
||
|
||
foreach closeparen [select_by_type closeparen] {
|
||
if {![is_at_begin_of_line $closeparen]} continue
|
||
|
||
warn "put closing parenthesis at the end of previous line" $closeparen
|
||
remove_newline_in_front_of [next_leaf $closeparen] ""
|
||
}
|
||
|
||
#
|
||
# Check for absence of newline at beginning of inherit block
|
||
#
|
||
|
||
foreach inherit [select_by_type inherit] {
|
||
if {[regexp {<EFBFBD>colon\d+<EFBFBD>\s*\n\s*<EFBFBD>([^<EFBFBD>]+)<EFBFBD>} $tok_text($inherit) dummy tag] == 0} {
|
||
continue }
|
||
|
||
if {![is_at_begin_of_line $tag]} continue
|
||
|
||
warn "remove linebreak after colon" $tag
|
||
remove_newline_in_front_of [next_leaf $tag] " "
|
||
}
|
||
|
||
#
|
||
# Check for superfluous lines
|
||
#
|
||
|
||
foreach tok_type {parenblk argparenblk initializer funcsignature inherit funcdecl funcimpl enum} {
|
||
foreach token [select_by_type $tok_type] {
|
||
|
||
# remove leading comment
|
||
set string $tok_text($token)
|
||
regsub {^\s*<EFBFBD>m?lcomment\d+<EFBFBD>\n} $string "" string
|
||
|
||
# if token contains no newline, there is nothing to optimize
|
||
set expanded [expand $string]
|
||
set num_newlines [regexp -all {\n} $expanded dummy]
|
||
if {$num_newlines == 0} continue
|
||
|
||
# if token contains an empty line, keep it that way
|
||
if {[regexp {\n\n} $expanded dummy]} continue
|
||
|
||
# check it token fits on a single line
|
||
if {[calc_merged_line_length $token] > 79} continue
|
||
|
||
warn "merge line with following lines" $token
|
||
|
||
if {$config_fix == 0} continue
|
||
|
||
while {[regexp {(<EFBFBD>m?lcomment\d+<EFBFBD>\n.*)\n} $tok_text($token)]} {
|
||
regsub {(<EFBFBD>m?lcomment\d+<EFBFBD>\n.*)\n} $tok_text($token) {\1} tok_text($token)
|
||
}
|
||
|
||
foreach tok "$token [select_by_type {.*} $token]" {
|
||
# if {[is_type $tok mlcomment]} continue
|
||
while {[regexp {\n\s*<EFBFBD>([^<EFBFBD>]+)<EFBFBD>} $tok_text($tok) dummy sub_tok]} {
|
||
|
||
# indentation is always located at the leaf
|
||
set sub_tok [next_leaf $sub_tok]
|
||
|
||
regsub {\n\s*(<EFBFBD>[^<EFBFBD>]+<EFBFBD>)} $tok_text($tok) " \\1" tok_text($tok)
|
||
regsub {^\s*} $tok_text($sub_tok) "" tok_text($sub_tok)
|
||
|
||
#
|
||
# If newline was located at the begin of a parenthesis block, remove the
|
||
# space after the open parenthesis
|
||
#
|
||
regsub {(<EFBFBD>openparen\d+<EFBFBD>)\s*(<EFBFBD>[^<EFBFBD>]+<EFBFBD>)} $tok_text($tok) "\\1\\2" tok_text($tok)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
#
|
||
# Comment functions at their declaration, not their implementation
|
||
#
|
||
|
||
msg "Checking location of comments..."
|
||
|
||
proc check_impl_comment_policy { impl } {
|
||
global tok_text
|
||
|
||
if {[is_within $impl classblock]} return
|
||
if {[is_within $impl tplfunc]} return
|
||
if {[llength [select_by_type mlcomment $impl]] == 0} return
|
||
|
||
# check if function has no inline or static modifier
|
||
set modifier_tokens [select_by_type modifier $impl]
|
||
|
||
set is_local 0
|
||
foreach modifier_token $modifier_tokens {
|
||
set modifier [expand_token $modifier_token]
|
||
if {[regexp {\mstatic\M} $modifier dummy]} { set is_local 1 }
|
||
if {[regexp {\minline\M} $modifier dummy]} { set is_local 1 }
|
||
}
|
||
|
||
if {[regexp {^\s*<EFBFBD>mlcomment\d+<EFBFBD>} $tok_text($impl) dummy] == 0} return
|
||
|
||
set funcname [expand_token [select_by_type identifier [select_by_type funcsignature $impl 1] 1]]
|
||
if {!$is_local} {
|
||
warn "move description of non-local \"$funcname\" to its declaration" $impl
|
||
}
|
||
}
|
||
|
||
proc check_impl_comment_style { impl } {
|
||
global tok_text
|
||
global config_fix
|
||
|
||
if {[regexp {^\s*<EFBFBD>lcomment} $tok_text($impl) dummy]} {
|
||
warn "turn function-header comment into multi-line comment" impl
|
||
return
|
||
}
|
||
|
||
# if no function header exists, there is nothing to check
|
||
if {[regexp {^\s*<EFBFBD>(mlcomment\d+)<EFBFBD>} $tok_text($impl) dummy mlcomment] == 0} {
|
||
return }
|
||
|
||
if {[regexp {^\s*\/\*\*\n} $tok_text($mlcomment)] == 0} {
|
||
warn "function-header comment should start with '/**'" $mlcomment
|
||
|
||
if {$config_fix} {
|
||
regsub {^(\s*)\/\*+\n} $tok_text($mlcomment) "\\1/**\n" tok_text($mlcomment)
|
||
}
|
||
}
|
||
|
||
if {[regexp {\n[\t ]*\*\/$} $tok_text($mlcomment)] == 0} {
|
||
warn "function-header comment should end with '*/'" $mlcomment
|
||
|
||
if {$config_fix} {
|
||
regsub {(\n[\t ]*)[* ]*\*\/ *$} $tok_text($mlcomment) "\\1\*\/" tok_text($mlcomment)
|
||
}
|
||
}
|
||
|
||
if {[regexp {^[^\w]*[a-z]} $tok_text($mlcomment)]} {
|
||
warn "brief description should start with upper case" $mlcomment
|
||
return
|
||
}
|
||
}
|
||
|
||
foreach tok_type {funcimpl constimpl destimpl} {
|
||
foreach impl_token [select_by_type $tok_type] {
|
||
check_impl_comment_policy $impl_token
|
||
check_impl_comment_style $impl_token
|
||
}
|
||
}
|
||
|
||
#
|
||
# Check function header comments
|
||
#
|
||
|
||
msg "Checking comments..."
|
||
|
||
proc check_upper_case { string message {token ""} } {
|
||
if {[string toupper $string 0 0] == $string} return
|
||
warn $message $token
|
||
}
|
||
|
||
|
||
proc check_mlcomment { token } {
|
||
global tok_text
|
||
global tok_line
|
||
global config_fix
|
||
set string $tok_text($token)
|
||
set brief_pattern {\\brief\s+([^\n]+)\n}
|
||
if {[regexp $brief_pattern $string dummy brief]} {
|
||
|
||
check_upper_case $brief "start brief decription with upper case" $token
|
||
set brief [string toupper $brief 0 0]
|
||
|
||
warn "ommit '\\brief' tag for brief description comment, use" $token
|
||
warn "/**" $token
|
||
warn " * $brief" $token
|
||
warn " *" $token
|
||
|
||
regsub $brief_pattern $string "$brief\n" string
|
||
regsub {\/\*\n} $string "/**\n" string
|
||
}
|
||
|
||
set pattern {(/\*[^\\]*\n)([\t ]*\*)\s*\\}
|
||
if {[regexp $pattern $string dummy start indent]} {
|
||
if {[regexp {[^\*]\n$} $start dummy]} {
|
||
warn "brief description of comment should be followed by an empty line" $token
|
||
regsub $pattern $string "$start$indent\n$indent \\" string
|
||
}
|
||
}
|
||
|
||
if {$config_fix} { set tok_text($token) $string }
|
||
}
|
||
|
||
|
||
proc is_at_begin_of_parent { token } {
|
||
global tok_text
|
||
return [regexp "^\\s*<EFBFBD>$token<EFBFBD>" $tok_text([get_parent $token]) dummy]
|
||
}
|
||
|
||
|
||
foreach mlcomment [select_by_type mlcomment] {
|
||
|
||
# do not look at file header
|
||
if {[get_parent $mlcomment] == "content0" && [is_at_begin_of_parent $mlcomment]} continue
|
||
|
||
check_mlcomment $mlcomment
|
||
}
|
||
|
||
|
||
abort
|