All of lore.kernel.org
 help / color / mirror / Atom feed
* [PATCH 0/2] checkpatch: Add --strict macro argument tests
@ 2016-09-13  5:43 Joe Perches
  2016-09-13  5:43 ` [PATCH 1/2] checkpatch: Add --strict test for macro argument reuse Joe Perches
  2016-09-13  5:43 ` [PATCH 2/2] checkpatch: Add --strict test for precedence challenged macro arguments Joe Perches
  0 siblings, 2 replies; 4+ messages in thread
From: Joe Perches @ 2016-09-13  5:43 UTC (permalink / raw)
  To: Andrew Morton, linux-kernel; +Cc: Julia Lawall, Dan Carpenter, Andy Whitcroft

This is rather better than the first submission.
I think this is acceptable and doesn't need to be RFC.

Joe Perches (2):
  checkpatch: Add --strict test for macro argument reuse
  checkpatch: Add --strict test for precedence challenged macro arguments

 scripts/checkpatch.pl | 50 ++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 42 insertions(+), 8 deletions(-)

-- 
2.10.0.rc2.1.g053435c

^ permalink raw reply	[flat|nested] 4+ messages in thread

* [PATCH 1/2] checkpatch: Add --strict test for macro argument reuse
  2016-09-13  5:43 [PATCH 0/2] checkpatch: Add --strict macro argument tests Joe Perches
@ 2016-09-13  5:43 ` Joe Perches
  2016-09-13  5:43 ` [PATCH 2/2] checkpatch: Add --strict test for precedence challenged macro arguments Joe Perches
  1 sibling, 0 replies; 4+ messages in thread
From: Joe Perches @ 2016-09-13  5:43 UTC (permalink / raw)
  To: Andrew Morton, Andy Whitcroft; +Cc: Julia Lawall, Dan Carpenter, linux-kernel

If a macro argument is used multiple times in the macro definition,
the macro argument may have an unexpected side-effect.

Add a test (MACRO_ARG_REUSE) for that condition which is only
emitted with command-line option --strict.

Signed-off-by: Joe Perches <joe@perches.com>
---
 scripts/checkpatch.pl | 43 +++++++++++++++++++++++++++++++++++--------
 1 file changed, 35 insertions(+), 8 deletions(-)

diff --git a/scripts/checkpatch.pl b/scripts/checkpatch.pl
index 3fa2b2e..f135f8e 100755
--- a/scripts/checkpatch.pl
+++ b/scripts/checkpatch.pl
@@ -4753,7 +4753,17 @@ sub process {
 			$has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
 			$has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
 
-			$dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
+			$dstat =~ s/^.\s*\#\s*define\s+$Ident(\([^\)]*\))?\s*//;
+			my $define_args = $1;
+			my $define_stmt = $dstat;
+			my @def_args = ();
+
+			if (defined $define_args && $define_args ne "") {
+				$define_args = substr($define_args, 1, length($define_args) - 2);
+				$define_args =~ s/\s*//g;
+				@def_args = split(",", $define_args);
+			}
+
 			$dstat =~ s/$;//g;
 			$dstat =~ s/\\\n.//g;
 			$dstat =~ s/^\s*//s;
@@ -4789,6 +4799,15 @@ sub process {
 				^\[
 			}x;
 			#print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
+
+			$ctx =~ s/\n*$//;
+			my $herectx = $here . "\n";
+			my $stmt_cnt = statement_rawlines($ctx);
+
+			for (my $n = 0; $n < $stmt_cnt; $n++) {
+				$herectx .= raw_line($linenr, $n) . "\n";
+			}
+
 			if ($dstat ne '' &&
 			    $dstat !~ /^(?:$Ident|-?$Constant),$/ &&			# 10, // foo(),
 			    $dstat !~ /^(?:$Ident|-?$Constant);$/ &&			# foo();
@@ -4804,13 +4823,6 @@ sub process {
 			    $dstat !~ /^\(\{/ &&						# ({...
 			    $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
 			{
-				$ctx =~ s/\n*$//;
-				my $herectx = $here . "\n";
-				my $cnt = statement_rawlines($ctx);
-
-				for (my $n = 0; $n < $cnt; $n++) {
-					$herectx .= raw_line($linenr, $n) . "\n";
-				}
 
 				if ($dstat =~ /;/) {
 					ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
@@ -4819,6 +4831,21 @@ sub process {
 					ERROR("COMPLEX_MACRO",
 					      "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
 				}
+
+			}
+# check if any macro arguments are reused (ignore '...' and 'type')
+			foreach my $arg (@def_args) {
+			        next if ($arg =~ /\.\.\./);
+			        next if ($arg =~ /^type$/);
+				my $tmp = $define_stmt;
+				$tmp =~ s/\b(typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
+				$tmp =~ s/\#\s*$arg\b//g;
+				$tmp =~ s/\b$arg\s*\#\#//g;
+				my $use_cnt = $tmp =~ s/\b$arg\b//g;
+				if ($use_cnt > 1) {
+					CHK("MACRO_ARG_REUSE",
+					    "Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
+				}
 			}
 
 # check for macros with flow control, but without ## concatenation
-- 
2.10.0.rc2.1.g053435c

^ permalink raw reply related	[flat|nested] 4+ messages in thread

* [PATCH 2/2] checkpatch: Add --strict test for precedence challenged macro arguments
  2016-09-13  5:43 [PATCH 0/2] checkpatch: Add --strict macro argument tests Joe Perches
  2016-09-13  5:43 ` [PATCH 1/2] checkpatch: Add --strict test for macro argument reuse Joe Perches
@ 2016-09-13  5:43 ` Joe Perches
  2016-09-13  5:53   ` [PATCH V2] " Joe Perches
  1 sibling, 1 reply; 4+ messages in thread
From: Joe Perches @ 2016-09-13  5:43 UTC (permalink / raw)
  To: Andrew Morton, Andy Whitcroft; +Cc: Julia Lawall, Dan Carpenter, linux-kernel

Add a test for macro arguents that have a non-comma leading or trailing
operator where the argument isn't parenthesized to avoid possible precedence
issues.

Signed-off-by: Joe Perches <joe@perches.com>
---
 scripts/checkpatch.pl | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/scripts/checkpatch.pl b/scripts/checkpatch.pl
index f135f8e..6e067e5 100755
--- a/scripts/checkpatch.pl
+++ b/scripts/checkpatch.pl
@@ -4836,7 +4836,7 @@ sub process {
 # check if any macro arguments are reused (ignore '...' and 'type')
 			foreach my $arg (@def_args) {
 			        next if ($arg =~ /\.\.\./);
-			        next if ($arg =~ /^type$/);
+			        next if ($arg =~ /^type$/i);
 				my $tmp = $define_stmt;
 				$tmp =~ s/\b(typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
 				$tmp =~ s/\#\s*$arg\b//g;
@@ -4846,6 +4846,13 @@ sub process {
 					CHK("MACRO_ARG_REUSE",
 					    "Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
 				}
++# check if any macro arguments may have other precedence issues
+				if ($define_stmt =~ m/($Operators)?\s*\b$arg\b\s*($Operators)?/m &&
+				    ((defined($1) && $1 ne ',') ||
+				     (defined($2) && $2 ne ','))) {
+					CHK("MACRO_ARG_PRECEDENCE",
+					    "Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
+				}
 			}
 
 # check for macros with flow control, but without ## concatenation
-- 
2.10.0.rc2.1.g053435c

^ permalink raw reply related	[flat|nested] 4+ messages in thread

* [PATCH V2] checkpatch: Add --strict test for precedence challenged macro arguments
  2016-09-13  5:43 ` [PATCH 2/2] checkpatch: Add --strict test for precedence challenged macro arguments Joe Perches
@ 2016-09-13  5:53   ` Joe Perches
  0 siblings, 0 replies; 4+ messages in thread
From: Joe Perches @ 2016-09-13  5:53 UTC (permalink / raw)
  To: Andrew Morton, Andy Whitcroft; +Cc: Julia Lawall, Dan Carpenter, linux-kernel

Add a test for macro arguents that have a non-comma leading or trailing
operator where the argument isn't parenthesized to avoid possible precedence
issues.

Signed-off-by: Joe Perches <joe@perches.com>
---

V2: Fix silly comment typo

 scripts/checkpatch.pl | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/scripts/checkpatch.pl b/scripts/checkpatch.pl
index f135f8e..ea1a7ad 100755
--- a/scripts/checkpatch.pl
+++ b/scripts/checkpatch.pl
@@ -4836,7 +4836,7 @@ sub process {
 # check if any macro arguments are reused (ignore '...' and 'type')
 			foreach my $arg (@def_args) {
 			        next if ($arg =~ /\.\.\./);
-			        next if ($arg =~ /^type$/);
+			        next if ($arg =~ /^type$/i);
 				my $tmp = $define_stmt;
 				$tmp =~ s/\b(typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
 				$tmp =~ s/\#\s*$arg\b//g;
@@ -4845,6 +4845,13 @@ sub process {
 				if ($use_cnt > 1) {
 					CHK("MACRO_ARG_REUSE",
 					    "Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
+				    }
+# check if any macro arguments may have other precedence issues
+				if ($define_stmt =~ m/($Operators)?\s*\b$arg\b\s*($Operators)?/m &&
+				    ((defined($1) && $1 ne ',') ||
+				     (defined($2) && $2 ne ','))) {
+					CHK("MACRO_ARG_PRECEDENCE",
+					    "Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
 				}
 			}
 
-- 
2.10.0.rc2.1.g053435c

^ permalink raw reply related	[flat|nested] 4+ messages in thread

end of thread, other threads:[~2016-09-13  5:53 UTC | newest]

Thread overview: 4+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2016-09-13  5:43 [PATCH 0/2] checkpatch: Add --strict macro argument tests Joe Perches
2016-09-13  5:43 ` [PATCH 1/2] checkpatch: Add --strict test for macro argument reuse Joe Perches
2016-09-13  5:43 ` [PATCH 2/2] checkpatch: Add --strict test for precedence challenged macro arguments Joe Perches
2016-09-13  5:53   ` [PATCH V2] " Joe Perches

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.