Commit 1813087d authored by Joe Perches's avatar Joe Perches Committed by Linus Torvalds
Browse files

checkpatch: add test for native c90 types in unusual order 



c90 section "6.7.2 Type Specifiers" says:
    "type specifiers may occur in any order"

That means that:
    short int is the same as int short
    unsigned short int is the same as int unsigned short
    etc...

checkpatch currently parses only a subset of these allowed types.

For instance: "unsigned short" and "signed short" are found by
checkpatch as a specific type, but none of the or "int short" or "int
signed short" variants are found.

Add another table for the "kernel style misordered" variants.

Add this misordered table to the findable types.

Warn when the misordered style is used.

This improves the "Missing a blank line after declarations" test as it
depends on the correct parsing of the $Declare variable which looks for
"$Type $Ident;" (ie: declarations like "int foo;").

Signed-off-by: default avatarJoe Perches <joe@perches.com>
Acked-by: default avatarAndy Whitcroft <apw@canonical.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 0c773d9d

scripts/checkpatch.pl

+44 −0
Original line number Diff line number Diff line
@@ -309,9 +309,12 @@ our $Operators = qr{ 
our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;



our $NonptrType;

our $NonptrTypeMisordered;

our $NonptrTypeWithAttr;

our $Type;

our $TypeMisordered;

our $Declare;

our $DeclareMisordered;



our $NON_ASCII_UTF8	= qr{

	[\xC2-\xDF][\x80-\xBF]               # non-overlong 2-byte
@@ -353,6 +356,25 @@ our $signature_tags = qr{(?xi: 
	Cc:

)};



our @typeListMisordered = (

	qr{char\s+(?:un)?signed},

	qr{int\s+(?:(?:un)?signed\s+)?short\s},

	qr{int\s+short(?:\s+(?:un)?signed)},

	qr{short\s+int(?:\s+(?:un)?signed)},

	qr{(?:un)?signed\s+int\s+short},

	qr{short\s+(?:un)?signed},

	qr{long\s+int\s+(?:un)?signed},

	qr{int\s+long\s+(?:un)?signed},

	qr{long\s+(?:un)?signed\s+int},

	qr{int\s+(?:un)?signed\s+long},

	qr{int\s+(?:un)?signed},

	qr{int\s+long\s+long\s+(?:un)?signed},

	qr{long\s+long\s+int\s+(?:un)?signed},

	qr{long\s+long\s+(?:un)?signed\s+int},

	qr{long\s+long\s+(?:un)?signed},

	qr{long\s+(?:un)?signed},

);



our @typeList = (

	qr{void},

	qr{(?:(?:un)?signed\s+)?char},
@@ -373,6 +395,7 @@ our @typeList = ( 
	qr{${Ident}_t},

	qr{${Ident}_handler},

	qr{${Ident}_handler_fn},

	@typeListMisordered,

);

our @typeListWithAttr = (

	@typeList,
@@ -414,6 +437,7 @@ our $allowed_asm_includes = qr{(?x: 
sub build_types {

	my $mods = "(?x:  \n" . join("|\n  ", @modifierList) . "\n)";

	my $all = "(?x:  \n" . join("|\n  ", @typeList) . "\n)";

	my $Misordered = "(?x:  \n" . join("|\n  ", @typeListMisordered) . "\n)";

	my $allWithAttr = "(?x:  \n" . join("|\n  ", @typeListWithAttr) . "\n)";

	$Modifier	= qr{(?:$Attribute|$Sparse|$mods)};

	$NonptrType	= qr{
@@ -425,6 +449,13 @@ sub build_types { 
			)

			(?:\s+$Modifier|\s+const)*

		  }x;

	$NonptrTypeMisordered	= qr{

			(?:$Modifier\s+|const\s+)*

			(?:

				(?:${Misordered}\b)

			)

			(?:\s+$Modifier|\s+const)*

		  }x;

	$NonptrTypeWithAttr	= qr{

			(?:$Modifier\s+|const\s+)*

			(?:
@@ -439,7 +470,13 @@ sub build_types { 
			(?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?

			(?:\s+$Inline|\s+$Modifier)*

		  }x;

	$TypeMisordered	= qr{

			$NonptrTypeMisordered

			(?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?

			(?:\s+$Inline|\s+$Modifier)*

		  }x;

	$Declare	= qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};

	$DeclareMisordered	= qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};

}

build_types();
@@ -2987,6 +3024,13 @@ sub process { 
			}

		}



# check for misordered declarations of char/short/int/long with signed/unsigned

		while ($sline =~ m{(\b$TypeMisordered\b)}g) {

			my $tmp = trim($1);

			WARN("MISORDERED_TYPE",

			     "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);

		}



# check for static const char * arrays.

		if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {

			WARN("STATIC_CONST_CHAR_ARRAY",

CRA Git | Maintained and supported by SUSTech CRA and CCSE